/*

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

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

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

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.Serializable;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.util.Collection;

import java.util.LinkedList;

import java.util.List;

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

/**

 * A container for data needed to instantiate a specific {@link ScriptFunction} at runtime.

 * Instances of this class are created during codegen and stored in script classes'

 * constants array to reduce function instantiation overhead during runtime.

 */

public abstract class ScriptFunctionData implements Serializable {

    static final int MAX_ARITY = LinkerCallSite.ARGLIMIT;

    static {

        // Assert it fits in a byte, as that's what we store it in. It's just a size optimization though, so if needed

        // "byte arity" field can be widened.

        assert MAX_ARITY < 256;

    }

    /** Name of the function or "" for anonymous functions */

    protected final String name;

    /**

     * A list of code versions of a function sorted in ascending order of generic descriptors.

     */

    protected transient LinkedList<CompiledFunction> code = new LinkedList<>();

    /** Function flags */

    protected int flags;

    // Parameter arity of the function, corresponding to "f.length". E.g. "function f(a, b, c) { ... }" arity is 3, and

    // some built-in ECMAScript functions have their arity declared by the specification. Note that regardless of this

    // value, the function might still be capable of receiving variable number of arguments, see isVariableArity.

    private int arity;

    /**

     * A pair of method handles used for generic invoker and constructor. Field is volatile as it can be initialized by

     * multiple threads concurrently, but we still tolerate a race condition in it as all values stored into it are

     * idempotent.

     */

    private volatile transient GenericInvokers genericInvokers;

    private static final MethodHandle BIND_VAR_ARGS = findOwnMH("bindVarArgs", Object[].class, Object[].class, Object[].class);

    /** Is this a strict mode function? */

    public static final int IS_STRICT      = 1 << 0;

    /** Is this a built-in function? */

    public static final int IS_BUILTIN     = 1 << 1;

    /** Is this a constructor function? */

    public static final int IS_CONSTRUCTOR = 1 << 2;

    /** Does this function expect a callee argument? */

    public static final int NEEDS_CALLEE   = 1 << 3;

    /** Does this function make use of the this-object argument? */

    public static final int USES_THIS      = 1 << 4;

    /** Is this a variable arity function? */

    public static final int IS_VARIABLE_ARITY = 1 << 5;

    /** Flag for strict or built-in functions */

    public static final int IS_STRICT_OR_BUILTIN = IS_STRICT | IS_BUILTIN;

    /** Flag for built-in constructors */

    public static final int IS_BUILTIN_CONSTRUCTOR = IS_BUILTIN | IS_CONSTRUCTOR;

    /** Flag for strict constructors */

    public static final int IS_STRICT_CONSTRUCTOR = IS_STRICT | IS_CONSTRUCTOR;

    private static final long serialVersionUID = 4252901245508769114L;

    /**

     * Constructor

     *

     * @param name  script function name

     * @param arity arity

     * @param flags the function flags

     */

    ScriptFunctionData(final String name, final int arity, final int flags) {

        this.name  = name;

        this.flags = flags;

        setArity(arity);

    }

    final int getArity() {

        return arity;

    }

    final boolean isVariableArity() {

        return (flags & IS_VARIABLE_ARITY) != 0;

    }

    /**

     * Used from e.g. Native*$Constructors as an explicit call. TODO - make arity immutable and final

     * @param arity new arity

     */

    void setArity(final int arity) {

        if(arity < 0 || arity > MAX_ARITY) {

            throw new IllegalArgumentException(String.valueOf(arity));

        }

        this.arity = arity;

    }

    CompiledFunction bind(final CompiledFunction originalInv, final ScriptFunction fn, final Object self, final Object[] args) {

        final MethodHandle boundInvoker = bindInvokeHandle(originalInv.createComposableInvoker(), fn, self, args);

        if (isConstructor()) {

            return new CompiledFunction(boundInvoker, bindConstructHandle(originalInv.createComposableConstructor(), fn, args), null);

        }

        return new CompiledFunction(boundInvoker);

    }

    /**

     * Is this a ScriptFunction generated with strict semantics?

     * @return true if strict, false otherwise

     */

    public boolean isStrict() {

        return (flags & IS_STRICT) != 0;

    }

    /**

     * Return the complete internal function name for this

     * data, not anonymous or similar. May be identical

     * @return internal function name

     */

    protected String getFunctionName() {

        return getName();

    }

    boolean isBuiltin() {

        return (flags & IS_BUILTIN) != 0;

    }

    boolean isConstructor() {

        return (flags & IS_CONSTRUCTOR) != 0;

    }

    abstract boolean needsCallee();

    /**

     * Returns true if this is a non-strict, non-built-in function that requires non-primitive this argument

     * according to ECMA 10.4.3.

     * @return true if this argument must be an object

     */

    boolean needsWrappedThis() {

        return (flags & USES_THIS) != 0 && (flags & IS_STRICT_OR_BUILTIN) == 0;

    }

    String toSource() {

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

    }

    String getName() {

        return name;

    }

    /**

     * Get this function as a String containing its source code. If no source code

     * exists in this ScriptFunction, its contents will be displayed as {@code [native code]}

     *

     * @return string representation of this function

     */

    @Override

    public String toString() {

        return name.isEmpty() ? "<anonymous>" : name;

    }

    /**

     * Verbose description of data

     * @return verbose description

     */

    public String toStringVerbose() {

        final StringBuilder sb = new StringBuilder();

        sb.append("name='").

                append(name.isEmpty() ? "<anonymous>" : name).

                append("' ").

                append(code.size()).

                append(" invokers=").

                append(code);

        return sb.toString();

    }

    /**

     * Pick the best invoker, i.e. the one version of this method with as narrow and specific

     * types as possible. If the call site arguments are objects, but boxed primitives we can

     * also try to get a primitive version of the method and do an unboxing filter, but then

     * we need to insert a guard that checks the argument is really always a boxed primitive

     * and not suddenly a "real" object

     *

     * @param callSiteType callsite type

     * @return compiled function object representing the best invoker.

     */

    final CompiledFunction getBestInvoker(final MethodType callSiteType, final ScriptObject runtimeScope) {

        return getBestInvoker(callSiteType, runtimeScope, CompiledFunction.NO_FUNCTIONS);

    }

    final CompiledFunction getBestInvoker(final MethodType callSiteType, final ScriptObject runtimeScope, final Collection<CompiledFunction> forbidden) {

        final CompiledFunction cf = getBest(callSiteType, runtimeScope, forbidden);

        assert cf != null;

        return cf;

    }

    final CompiledFunction getBestConstructor(final MethodType callSiteType, final ScriptObject runtimeScope, final Collection<CompiledFunction> forbidden) {

        if (!isConstructor()) {

            throw typeError("not.a.constructor", toSource());

        }

        // Constructor call sites don't have a "this", but getBest is meant to operate on "callee, this, ..." style

        final CompiledFunction cf = getBest(callSiteType.insertParameterTypes(1, Object.class), runtimeScope, forbidden);

        return cf;

    }

    /**

     * If we can have lazy code generation, this is a hook to ensure that the code has been compiled.

     * This does not guarantee the code been installed in this {@code ScriptFunctionData} instance

     */

    protected void ensureCompiled() {

        //empty

    }

    /**

     * Return a generic Object/Object invoker for this method. It will ensure code

     * is generated, get the most generic of all versions of this function and adapt it

     * to Objects.

     *

     * @param runtimeScope the runtime scope. It can be used to evaluate types of scoped variables to guide the

     * optimistic compilation, should the call to this method trigger code compilation. Can be null if current runtime

     * scope is not known, but that might cause compilation of code that will need more deoptimization passes.

     * @return generic invoker of this script function

     */

    final MethodHandle getGenericInvoker(final ScriptObject runtimeScope) {

        // This method has race conditions both on genericsInvoker and genericsInvoker.invoker, but even if invoked

        // concurrently, they'll create idempotent results, so it doesn't matter. We could alternatively implement this

        // using java.util.concurrent.AtomicReferenceFieldUpdater, but it's hardly worth it.

        final GenericInvokers lgenericInvokers = ensureGenericInvokers();

        MethodHandle invoker = lgenericInvokers.invoker;

        if(invoker == null) {

            lgenericInvokers.invoker = invoker = createGenericInvoker(runtimeScope);

        }

        return invoker;

    }

    private MethodHandle createGenericInvoker(final ScriptObject runtimeScope) {

        return makeGenericMethod(getGeneric(runtimeScope).createComposableInvoker());

    }

    final MethodHandle getGenericConstructor(final ScriptObject runtimeScope) {

        // This method has race conditions both on genericsInvoker and genericsInvoker.constructor, but even if invoked

        // concurrently, they'll create idempotent results, so it doesn't matter. We could alternatively implement this

        // using java.util.concurrent.AtomicReferenceFieldUpdater, but it's hardly worth it.

        final GenericInvokers lgenericInvokers = ensureGenericInvokers();

        MethodHandle constructor = lgenericInvokers.constructor;

        if(constructor == null) {

            lgenericInvokers.constructor = constructor = createGenericConstructor(runtimeScope);

        }

        return constructor;

    }

    private MethodHandle createGenericConstructor(final ScriptObject runtimeScope) {

        return makeGenericMethod(getGeneric(runtimeScope).createComposableConstructor());

    }

    private GenericInvokers ensureGenericInvokers() {

        GenericInvokers lgenericInvokers = genericInvokers;

        if(lgenericInvokers == null) {

            genericInvokers = lgenericInvokers = new GenericInvokers();

        }

        return lgenericInvokers;

    }

    private static MethodType widen(final MethodType cftype) {

        final Class<?>[] paramTypes = new Class<?>[cftype.parameterCount()];

        for (int i = 0; i < cftype.parameterCount(); i++) {

            paramTypes[i] = cftype.parameterType(i).isPrimitive() ? cftype.parameterType(i) : Object.class;

        }

        return MH.type(cftype.returnType(), paramTypes);

    }

    /**

     * Used to find an apply to call version that fits this callsite.

     * We cannot just, as in the normal matcher case, return e.g. (Object, Object, int)

     * for (Object, Object, int, int, int) or we will destroy the semantics and get

     * a function that, when padded with undefineds, behaves differently

     * @param type actual call site type

     * @return apply to call that perfectly fits this callsite or null if none found

     */

    CompiledFunction lookupExactApplyToCall(final MethodType type) {

        for (final CompiledFunction cf : code) {

            if (!cf.isApplyToCall()) {

                continue;

            }

            final MethodType cftype = cf.type();

            if (cftype.parameterCount() != type.parameterCount()) {

                continue;

            }

            if (widen(cftype).equals(widen(type))) {

                return cf;

            }

        }

        return null;

    }

    CompiledFunction pickFunction(final MethodType callSiteType, final boolean canPickVarArg) {

        for (final CompiledFunction candidate : code) {

            if (candidate.matchesCallSite(callSiteType, canPickVarArg)) {

                return candidate;

            }

        }

        return null;

    }

    /**

     * Returns the best function for the specified call site type.

     * @param callSiteType The call site type. Call site types are expected to have the form

     * {@code (callee, this[, args...])}.

     * @param runtimeScope the runtime scope. It can be used to evaluate types of scoped variables to guide the

     * optimistic compilation, should the call to this method trigger code compilation. Can be null if current runtime

     * scope is not known, but that might cause compilation of code that will need more deoptimization passes.

     * @return the best function for the specified call site type.

     */

    CompiledFunction getBest(final MethodType callSiteType, final ScriptObject runtimeScope, final Collection<CompiledFunction> forbidden) {

        assert callSiteType.parameterCount() >= 2 : callSiteType; // Must have at least (callee, this)

        assert callSiteType.parameterType(0).isAssignableFrom(ScriptFunction.class) : callSiteType; // Callee must be assignable from script function

        if (isRecompilable()) {

            final CompiledFunction candidate = pickFunction(callSiteType, false);

            if (candidate != null) {

                return candidate;

            }

            return pickFunction(callSiteType, true); //try vararg last

        }

        CompiledFunction best = null;

        for (final CompiledFunction candidate: code) {

            if (!forbidden.contains(candidate) && candidate.betterThanFinal(best, callSiteType)) {

                best = candidate;

            }

        }

        return best;

    }

    abstract boolean isRecompilable();

    CompiledFunction getGeneric(final ScriptObject runtimeScope) {

        return getBest(getGenericType(), runtimeScope, CompiledFunction.NO_FUNCTIONS);

    }

    /**

     * Get a method type for a generic invoker.

     * @return the method type for the generic invoker

     */

    abstract MethodType getGenericType();

    /**

     * Allocates an object using this function's allocator.

     *

     * @param map the property map for the allocated object.

     * @return the object allocated using this function's allocator, or null if the function doesn't have an allocator.

     */

    ScriptObject allocate(final PropertyMap map) {

        return null;

    }

    /**

     * Get the property map to use for objects allocated by this function.

     *

     * @return the property map for allocated objects.

     */

    PropertyMap getAllocatorMap() {

        return null;

    }

    /**

     * This method is used to create the immutable portion of a bound function.

     * See {@link ScriptFunction#makeBoundFunction(Object, Object[])}

     *

     * @param fn the original function being bound

     * @param self this reference to bind. Can be null.

     * @param args additional arguments to bind. Can be null.

     */

    ScriptFunctionData makeBoundFunctionData(final ScriptFunction fn, final Object self, final Object[] args) {

        final Object[] allArgs = args == null ? ScriptRuntime.EMPTY_ARRAY : args;

        final int length = args == null ? 0 : args.length;

        // Clear the callee and this flags

        final int boundFlags = flags & ~NEEDS_CALLEE & ~USES_THIS;

        final List<CompiledFunction> boundList = new LinkedList<>();

        final ScriptObject runtimeScope = fn.getScope();

        final CompiledFunction bindTarget = new CompiledFunction(getGenericInvoker(runtimeScope), getGenericConstructor(runtimeScope), null);

        boundList.add(bind(bindTarget, fn, self, allArgs));

        return new FinalScriptFunctionData(name, Math.max(0, getArity() - length), boundList, boundFlags);

    }

    /**

     * Convert this argument for non-strict functions according to ES 10.4.3

     *

     * @param thiz the this argument

     *

     * @return the converted this object

     */

    private Object convertThisObject(final Object thiz) {

        return needsWrappedThis() ? wrapThis(thiz) : thiz;

    }

    static Object wrapThis(final Object thiz) {

        if (!(thiz instanceof ScriptObject)) {

            if (JSType.nullOrUndefined(thiz)) {

                return Context.getGlobal();

            }

            if (isPrimitiveThis(thiz)) {

                return Context.getGlobal().wrapAsObject(thiz);

            }

        }

        return thiz;

    }

    static boolean isPrimitiveThis(final Object obj) {

    }

    /**

     * Creates an invoker method handle for a bound function.

     *

     * @param targetFn the function being bound

     * @param originalInvoker an original invoker method handle for the function. This can be its generic invoker or

     * any of its specializations.

     * @param self the "this" value being bound

     * @param args additional arguments being bound

     *

     * @return a bound invoker method handle that will bind the self value and the specified arguments. The resulting

     * invoker never needs a callee; if the original invoker needed it, it will be bound to {@code fn}. The resulting

     * invoker still takes an initial {@code this} parameter, but it is always dropped and the bound {@code self} passed

     * to the original invoker on invocation.

     */

    private MethodHandle bindInvokeHandle(final MethodHandle originalInvoker, final ScriptFunction targetFn, final Object self, final Object[] args) {

        // Is the target already bound? If it is, we won't bother binding either callee or self as they're already bound

        // in the target and will be ignored anyway.

        final boolean isTargetBound = targetFn.isBoundFunction();

        final boolean needsCallee = needsCallee(originalInvoker);

        assert needsCallee == needsCallee() : "callee contract violation 2";

        assert !(isTargetBound && needsCallee); // already bound functions don't need a callee

        final Object boundSelf = isTargetBound ? null : convertThisObject(self);

        final MethodHandle boundInvoker;

        if (isVarArg(originalInvoker)) {

            // First, bind callee and this without arguments