/*

 * 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.codegen.CompilerConstants.virtualCall;

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

import static jdk.nashorn.internal.lookup.Lookup.MH;

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

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

import static jdk.nashorn.internal.runtime.PropertyDescriptor.CONFIGURABLE;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.ENUMERABLE;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.GET;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.SET;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.VALUE;

import static jdk.nashorn.internal.runtime.PropertyDescriptor.WRITABLE;

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

import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.getArrayIndexNoThrow;

import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.isValidArrayIndex;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.util.AbstractMap;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import jdk.internal.dynalink.CallSiteDescriptor;

import jdk.internal.dynalink.linker.GuardedInvocation;

import jdk.internal.dynalink.linker.LinkRequest;

import jdk.internal.dynalink.support.CallSiteDescriptorFactory;

import jdk.nashorn.internal.codegen.CompilerConstants.Call;

import jdk.nashorn.internal.codegen.ObjectClassGenerator;

import jdk.nashorn.internal.lookup.Lookup;

import jdk.nashorn.internal.lookup.MethodHandleFactory;

import jdk.nashorn.internal.objects.AccessorPropertyDescriptor;

import jdk.nashorn.internal.objects.DataPropertyDescriptor;

import jdk.nashorn.internal.runtime.arrays.ArrayData;

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

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

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

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

/**

 * Base class for generic JavaScript objects.

 * <p>

 * Notes:

 * <ul>

 * <li>The map is used to identify properties in the object.</li>

 * <li>If the map is modified then it must be cloned and replaced.  This notifies

 *     any code that made assumptions about the object that things have changed.

 *     Ex. CallSites that have been validated must check to see if the map has

 *     changed (or a map from a different object type) and hence relink the method

 *     to call.</li>

 * <li>Modifications of the map include adding/deleting attributes or changing a

 *     function field value.</li>

 * </ul>

 */

public abstract class ScriptObject extends PropertyListenerManager implements PropertyAccess {

    /** Search fall back routine name for "no such method" */

    static final String NO_SUCH_METHOD_NAME   = "__noSuchMethod__";

    /** Search fall back routine name for "no such property" */

    static final String NO_SUCH_PROPERTY_NAME = "__noSuchProperty__";

    /** Per ScriptObject flag - is this a scope object? */

    public static final int IS_SCOPE       = 0b0000_0001;

    /** Per ScriptObject flag - is this an array object? */

    public static final int IS_ARRAY       = 0b0000_0010;

    /** Per ScriptObject flag - is this an arguments object? */

    public static final int IS_ARGUMENTS   = 0b0000_0100;

    /** Is this a prototype PropertyMap? */

    public static final int IS_PROTOTYPE   = 0b0000_1000;

    /** Spill growth rate - by how many elements does {@link ScriptObject#spill} when full */

    public static final int SPILL_RATE = 8;

    /** Map to property information and accessor functions. Ordered by insertion. */

    private PropertyMap map;

    /** objects proto. */

    private ScriptObject proto;

    /** Context of the object, lazily cached. */

    private Context context;

    /** Object flags. */

    private int flags;

    /** Area for properties added to object after instantiation, see {@link AccessorProperty} */

    public Object[] spill;

    /** Indexed array data. */

    private ArrayData arrayData;

    static final MethodHandle SETFIELD           = findOwnMH("setField",         void.class, CallSiteDescriptor.class, PropertyMap.class, PropertyMap.class, MethodHandle.class, Object.class, Object.class);

    static final MethodHandle SETSPILL           = findOwnMH("setSpill",         void.class, CallSiteDescriptor.class, PropertyMap.class, PropertyMap.class, int.class, Object.class, Object.class);

    static final MethodHandle SETSPILLWITHNEW    = findOwnMH("setSpillWithNew",  void.class, CallSiteDescriptor.class, PropertyMap.class, PropertyMap.class, int.class, Object.class, Object.class);

    static final MethodHandle SETSPILLWITHGROW   = findOwnMH("setSpillWithGrow", void.class, CallSiteDescriptor.class, PropertyMap.class, PropertyMap.class, int.class, int.class, Object.class, Object.class);

    private static final MethodHandle TRUNCATINGFILTER   = findOwnMH("truncatingFilter", Object[].class, int.class, Object[].class);

    private static final MethodHandle KNOWNFUNCPROPGUARD = findOwnMH("knownFunctionPropertyGuard", boolean.class, Object.class, PropertyMap.class, MethodHandle.class, Object.class, ScriptFunction.class);

    /** Method handle for getting a function argument at a given index. Used from MapCreator */

    public static final Call GET_ARGUMENT       = virtualCall(ScriptObject.class, "getArgument", Object.class, int.class);

    /** Method handle for setting a function argument at a given index. Used from MapCreator */

    public static final Call SET_ARGUMENT       = virtualCall(ScriptObject.class, "setArgument", void.class, int.class, Object.class);

    /** Method handle for getting the proto of a ScriptObject */

    public static final Call GET_PROTO          = virtualCallNoLookup(ScriptObject.class, "getProto", ScriptObject.class);

    /** Method handle for setting the proto of a ScriptObject */

    public static final Call SET_PROTO          = virtualCallNoLookup(ScriptObject.class, "setProto", void.class, ScriptObject.class);

    /** Method handle for setting the user accessors of a ScriptObject */

    public static final Call SET_USER_ACCESSORS = virtualCall(ScriptObject.class, "setUserAccessors", void.class, String.class, ScriptFunction.class, ScriptFunction.class);

    /**

     * Constructor

     */

    public ScriptObject() {

        this(null);

    }

    /**

    * Constructor

    *

    * @param map {@link PropertyMap} used to create the initial object

    */

    public ScriptObject(final PropertyMap map) {

        if (Context.DEBUG) {

            ScriptObject.count++;

        }

        this.arrayData = ArrayData.EMPTY_ARRAY;

        if (map == null) {

            this.setMap(PropertyMap.newMap(getClass()));

            return;

        }

        this.setMap(map);

    }

    /**

     * Copy all properties from the source object with their receiver bound to the source.

     * This function was known as mergeMap

     *

     * @param source The source object to copy from.

     */

    public void addBoundProperties(final ScriptObject source) {

        PropertyMap newMap = this.getMap();

        for (final Property property : source.getMap().getProperties()) {

            final String key = property.getKey();

            if (newMap.findProperty(key) == null) {

                if (property instanceof UserAccessorProperty) {

                    final UserAccessorProperty prop = this.newUserAccessors(key, property.getFlags(), property.getGetterFunction(source), property.getSetterFunction(source));

                    newMap = newMap.addProperty(prop);

                } else {

                    newMap = newMap.newPropertyBind((AccessorProperty)property, source);

                }

            }

        }

        this.setMap(newMap);

    }

    /**

     * Bind the method handle to the specified receiver, while preserving its original type (it will just ignore the

     * first argument in lieu of the bound argument).

     * @param methodHandle Method handle to bind to.

     * @param receiver     Object to bind.

     * @return Bound method handle.

     */

    static MethodHandle bindTo(final MethodHandle methodHandle, final Object receiver) {

        return MH.dropArguments(MH.bindTo(methodHandle, receiver), 0, methodHandle.type().parameterType(0));

    }

    /**

     * Return a property iterator.

     * @return Property iterator.

     */

    public Iterator<String> propertyIterator() {

        return new KeyIterator(this);

    }

    /**

     * Return a property value iterator.

     * @return Property value iterator.

     */

    public Iterator<Object> valueIterator() {

        return new ValueIterator(this);

    }

    /**

     * ECMA 8.10.1 IsAccessorDescriptor ( Desc )

     * @return true if this has a {@link AccessorPropertyDescriptor} with a getter or a setter

     */

    public final boolean isAccessorDescriptor() {

        return has(GET) || has(SET);

    }

    /**

     * ECMA 8.10.2 IsDataDescriptor ( Desc )

     * @return true if this has a {@link DataPropertyDescriptor}, i.e. the object has a property value and is writable

     */

    public final boolean isDataDescriptor() {

        return has(VALUE) || has(WRITABLE);

    }

    /**

     * ECMA 8.10.3 IsGenericDescriptor ( Desc )

     * @return true if this has a descriptor describing an {@link AccessorPropertyDescriptor} or {@link DataPropertyDescriptor}

     */

    public final boolean isGenericDescriptor() {

        return isAccessorDescriptor() || isDataDescriptor();

    }

    /**

      * ECMA 8.10.5 ToPropertyDescriptor ( Obj )

      *

      * @return property descriptor

      */

    public final PropertyDescriptor toPropertyDescriptor() {

        final GlobalObject global = (GlobalObject) Context.getGlobalTrusted();

        final PropertyDescriptor desc;

        if (isDataDescriptor()) {

            if (has(SET) || has(GET)) {

                throw typeError((ScriptObject)global, "inconsistent.property.descriptor");

            }

            desc = global.newDataDescriptor(UNDEFINED, false, false, false);

        } else if (isAccessorDescriptor()) {

            if (has(VALUE) || has(WRITABLE)) {

                throw typeError((ScriptObject)global, "inconsistent.property.descriptor");

            }

            desc = global.newAccessorDescriptor(UNDEFINED, UNDEFINED, false, false);

        } else {

            desc = global.newGenericDescriptor(false, false);

        }

        return desc.fillFrom(this);

    }

    /**

     * ECMA 8.10.5 ToPropertyDescriptor ( Obj )

     *

     * @param global  global scope object

     * @param obj object to create property descriptor from

     *

     * @return property descriptor

     */

    public static PropertyDescriptor toPropertyDescriptor(final ScriptObject global, final Object obj) {

        if (obj instanceof ScriptObject) {

            return ((ScriptObject)obj).toPropertyDescriptor();

        }

        throw typeError(global, "not.an.object", ScriptRuntime.safeToString(obj));

    }

    /**

     * ECMA 8.12.1 [[GetOwnProperty]] (P)

     *

     * @param key property key

     *

     * @return Returns the Property Descriptor of the named own property of this

     * object, or undefined if absent.

     */

    public Object getOwnPropertyDescriptor(final String key) {

        final Property property = getMap().findProperty(key);

        final GlobalObject global = (GlobalObject)Context.getGlobalTrusted();

        if (property != null) {

            final ScriptFunction get   = property.getGetterFunction(this);

            final ScriptFunction set   = property.getSetterFunction(this);

            final boolean configurable = property.isConfigurable();

            final boolean enumerable   = property.isEnumerable();

            final boolean writable     = property.isWritable();

            if (property instanceof UserAccessorProperty) {

                return global.newAccessorDescriptor(

                    (get != null) ?

                        get :

                        UNDEFINED,

                    (set != null) ?

                        set :

                        UNDEFINED,

                    configurable,

                    enumerable);

            }

            return global.newDataDescriptor(getWithProperty(property), configurable, enumerable, writable);

        }

        final int index = getArrayIndexNoThrow(key);

        final ArrayData array = getArray();

        if (array.has(index)) {

            return array.getDescriptor(global, index);

        }

        return UNDEFINED;

    }

    /**

     * ECMA 8.12.2 [[GetProperty]] (P)

     *

     * @param key property key

     *

     * @return Returns the fully populated Property Descriptor of the named property

     * of this object, or undefined if absent.

     */

    public Object getPropertyDescriptor(final String key) {

        final Object res = getOwnPropertyDescriptor(key);

        if (res != UNDEFINED) {

            return res;

        } else if (getProto() != null) {

            return getProto().getOwnPropertyDescriptor(key);

        } else {

            return UNDEFINED;

        }

    }

    /**

     * ECMA 8.12.9 [[DefineOwnProperty]] (P, Desc, Throw)

     *

     * @param key the property key

     * @param propertyDesc the property descriptor

     * @param reject is the property extensible - true means new definitions are rejected

     *

     * @return true if property was successfully defined

     */

    public boolean defineOwnProperty(final String key, final Object propertyDesc, final boolean reject) {

        final ScriptObject       global  = Context.getGlobalTrusted();

        final PropertyDescriptor desc    = toPropertyDescriptor(global, propertyDesc);

        final Object             current = getOwnPropertyDescriptor(key);

        final String             name    = JSType.toString(key);

        if (current == UNDEFINED) {

            if (isExtensible()) {

                // add a new own property

                addOwnProperty(key, desc);

                return true;

            }

            // new property added to non-extensible object

            if (reject) {

                throw typeError(global, "object.non.extensible", name, ScriptRuntime.safeToString(this));

            }

            return false;

        }

        // modifying an existing property

        final PropertyDescriptor currentDesc = (PropertyDescriptor) current;

        final PropertyDescriptor newDesc     = desc;

        if (newDesc.type() == PropertyDescriptor.GENERIC &&

            ! newDesc.has(CONFIGURABLE) && ! newDesc.has(ENUMERABLE)) {

            // every descriptor field is absent

            return true;

        }

        if (currentDesc.equals(newDesc)) {

            // every descriptor field of the new is same as the current

            return true;

        }

        if (! currentDesc.isConfigurable()) {

            if (newDesc.has(CONFIGURABLE) && newDesc.isConfigurable()) {

                // not configurable can not be made configurable

                if (reject) {

                    throw typeError(global, "cant.redefine.property", name, ScriptRuntime.safeToString(this));

                }

                return false;

            }

            if (newDesc.has(ENUMERABLE) &&

                currentDesc.isEnumerable() != newDesc.isEnumerable()) {

                // cannot make non-enumerable as enumerable or vice-versa

                if (reject) {

                    throw typeError(global, "cant.redefine.property", name, ScriptRuntime.safeToString(this));

                }

                return false;

            }

        }

        int propFlags = Property.mergeFlags(currentDesc, newDesc);

        Property property = getMap().findProperty(key);

        if (currentDesc.type() == PropertyDescriptor.DATA &&

            (newDesc.type() == PropertyDescriptor.DATA || newDesc.type() == PropertyDescriptor.GENERIC)) {

            if (! currentDesc.isConfigurable() && ! currentDesc.isWritable()) {

                if (newDesc.has(WRITABLE) && newDesc.isWritable() ||

                    newDesc.has(VALUE) && ! ScriptRuntime.sameValue(currentDesc.getValue(), newDesc.getValue())) {

                    if (reject) {

                        throw typeError(global, "cant.redefine.property", name, ScriptRuntime.safeToString(this));

                    }

                    return false;

                }

            }

            final boolean newValue = newDesc.has(VALUE);

            final Object value     = newValue? newDesc.getValue() : currentDesc.getValue();

            if (newValue && property != null) {

                // Temporarily clear flags.

                property = modifyOwnProperty(property, 0);

                set(key, value, getContext()._strict);

            }

            if (property == null) {

                // promoting an arrayData value to actual property

                addOwnProperty(key, propFlags, value);

                removeArraySlot(key);

            } else {

                // Now set the new flags

                modifyOwnProperty(property, propFlags);

            }

        } else if (currentDesc.type() == PropertyDescriptor.ACCESSOR &&

                   (newDesc.type() == PropertyDescriptor.ACCESSOR ||

                    newDesc.type() == PropertyDescriptor.GENERIC)) {

            if (! currentDesc.isConfigurable()) {

                if (newDesc.has(PropertyDescriptor.GET) && ! ScriptRuntime.sameValue(currentDesc.getGetter(), newDesc.getGetter()) ||

                    newDesc.has(PropertyDescriptor.SET) && ! ScriptRuntime.sameValue(currentDesc.getSetter(), newDesc.getSetter())) {

                    if (reject) {

                        throw typeError(global, "cant.redefine.property", name, ScriptRuntime.safeToString(this));

                    }

                    return false;

                }

            }

            // New set the new features.

            modifyOwnProperty(property, propFlags,

                                      newDesc.has(GET) ? newDesc.getGetter() : currentDesc.getGetter(),

                                      newDesc.has(SET) ? newDesc.getSetter() : currentDesc.getSetter());

        } else {

            // changing descriptor type

            if (! currentDesc.isConfigurable()) {

                // not configurable can not be made configurable

                if (reject) {

                    throw typeError(global, "cant.redefine.property", name, ScriptRuntime.safeToString(this));

                }

                return false;

            }

            propFlags = 0;

            // Preserve only configurable and enumerable from current desc

            // if those are not overridden in the new property descriptor.

            boolean value = newDesc.has(CONFIGURABLE)? newDesc.isConfigurable() : currentDesc.isConfigurable();

            if (!value) {

                propFlags |= Property.NOT_CONFIGURABLE;

            }

            value = newDesc.has(ENUMERABLE)? newDesc.isEnumerable() : currentDesc.isEnumerable();

            if (!value) {

                propFlags |= Property.NOT_ENUMERABLE;

            }

            final int type = newDesc.type();

            if (type == PropertyDescriptor.DATA) {

                // get writable from the new descriptor

                value = newDesc.has(WRITABLE) && newDesc.isWritable();

                if (! value) {

                    propFlags |= Property.NOT_WRITABLE;

                }

                // delete the old property

                deleteOwnProperty(property);

                // add new data property

                addOwnProperty(key, propFlags, newDesc.getValue());

            } else if (type == PropertyDescriptor.ACCESSOR) {

                if (property == null) {

                    addOwnProperty(key, propFlags,

                                     newDesc.has(GET) ? newDesc.getGetter() : null,

                                     newDesc.has(SET) ? newDesc.getSetter() : null);

                } else {

                    // Modify old property with the new features.

                    modifyOwnProperty(property, propFlags,

                                        newDesc.has(GET) ? newDesc.getGetter() : null,

                                        newDesc.has(SET) ? newDesc.getSetter() : null);

                }

            }