/*

 * 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.ObjectClassGenerator.PRIMITIVE_FIELD_TYPE;

import static jdk.nashorn.internal.codegen.ObjectClassGenerator.createGetter;

import static jdk.nashorn.internal.codegen.ObjectClassGenerator.createSetter;

import static jdk.nashorn.internal.codegen.ObjectClassGenerator.getFieldCount;

import static jdk.nashorn.internal.codegen.ObjectClassGenerator.getFieldName;

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

import static jdk.nashorn.internal.lookup.MethodHandleFactory.stripName;

import static jdk.nashorn.internal.runtime.JSType.getAccessorTypeIndex;

import static jdk.nashorn.internal.runtime.JSType.getNumberOfAccessorTypes;

import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.INVALID_PROGRAM_POINT;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.SwitchPoint;

import java.util.function.Supplier;

import java.util.logging.Level;

import jdk.nashorn.internal.codegen.ObjectClassGenerator;

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

import jdk.nashorn.internal.lookup.Lookup;

import jdk.nashorn.internal.objects.Global;

/**

 * An AccessorProperty is the most generic property type. An AccessorProperty is

 * represented as fields in a ScriptObject class.

 */

public class AccessorProperty extends Property {

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

    private static final MethodHandle REPLACE_MAP   = findOwnMH_S("replaceMap", Object.class, Object.class, PropertyMap.class);

    private static final MethodHandle INVALIDATE_SP = findOwnMH_S("invalidateSwitchPoint", Object.class, AccessorProperty.class, Object.class);

    private static final int NOOF_TYPES = getNumberOfAccessorTypes();

    private static final long serialVersionUID = 3371720170182154920L;

    /**

     * Properties in different maps for the same structure class will share their field getters and setters. This could

     * be further extended to other method handles that are looked up in the AccessorProperty constructor, but right now

     * these are the most frequently retrieved ones, and lookup of method handle natives only registers in the profiler

     * for them.

     */

    private static ClassValue<Accessors> GETTERS_SETTERS = new ClassValue<Accessors>() {

        @Override

        protected Accessors computeValue(final Class<?> structure) {

            return new Accessors(structure);

        }

    };

    private static class Accessors {

        final MethodHandle[] objectGetters;

        final MethodHandle[] objectSetters;

        final MethodHandle[] primitiveGetters;

        final MethodHandle[] primitiveSetters;

        /**

         * Normal

         * @param structure

         */

        Accessors(final Class<?> structure) {

            final int fieldCount = getFieldCount(structure);

            objectGetters    = new MethodHandle[fieldCount];

            objectSetters    = new MethodHandle[fieldCount];

            primitiveGetters = new MethodHandle[fieldCount];

            primitiveSetters = new MethodHandle[fieldCount];

            for (int i = 0; i < fieldCount; i++) {

                final String fieldName = getFieldName(i, Type.OBJECT);

                final Class<?> typeClass = Type.OBJECT.getTypeClass();

                objectGetters[i] = MH.asType(MH.getter(LOOKUP, structure, fieldName, typeClass), Lookup.GET_OBJECT_TYPE);

                objectSetters[i] = MH.asType(MH.setter(LOOKUP, structure, fieldName, typeClass), Lookup.SET_OBJECT_TYPE);

            }

            if (!StructureLoader.isSingleFieldStructure(structure.getName())) {

                for (int i = 0; i < fieldCount; i++) {

                    final String fieldNamePrimitive = getFieldName(i, PRIMITIVE_FIELD_TYPE);

                    final Class<?> typeClass = PRIMITIVE_FIELD_TYPE.getTypeClass();

                    primitiveGetters[i] = MH.asType(MH.getter(LOOKUP, structure, fieldNamePrimitive, typeClass), Lookup.GET_PRIMITIVE_TYPE);

                    primitiveSetters[i] = MH.asType(MH.setter(LOOKUP, structure, fieldNamePrimitive, typeClass), Lookup.SET_PRIMITIVE_TYPE);

                }

            }

        }

    }

    /**

     * Property getter cache

     *   Note that we can't do the same simple caching for optimistic getters,

     *   due to the fact that they are bound to a program point, which will

     *   produce different boun method handles wrapping the same access mechanism

     *   depending on callsite

     */

    private transient MethodHandle[] GETTER_CACHE = new MethodHandle[NOOF_TYPES];

    /**

     * Create a new accessor property. Factory method used by nasgen generated code.

     *

     * @param key           {@link Property} key.

     * @param propertyFlags {@link Property} flags.

     * @param getter        {@link Property} get accessor method.

     * @param setter        {@link Property} set accessor method.

     *

     * @return  New {@link AccessorProperty} created.

     */

    public static AccessorProperty create(final Object key, final int propertyFlags, final MethodHandle getter, final MethodHandle setter) {

        return new AccessorProperty(key, propertyFlags, -1, getter, setter);

    }

    /** Seed getter for the primitive version of this field (in -Dnashorn.fields.dual=true mode) */

    transient MethodHandle primitiveGetter;

    /** Seed setter for the primitive version of this field (in -Dnashorn.fields.dual=true mode) */

    transient MethodHandle primitiveSetter;

    /** Seed getter for the Object version of this field */

    transient MethodHandle objectGetter;

    /** Seed setter for the Object version of this field */

    transient MethodHandle objectSetter;

    /**

     * Delegate constructor for bound properties. This is used for properties created by

     * {@link ScriptRuntime#mergeScope} and the Nashorn {@code Object.bindProperties} method.

     * The former is used to add a script's defined globals to the current global scope while

     * still storing them in a JO-prefixed ScriptObject class.

     *

     * <p>All properties created by this constructor have the {@link #IS_BOUND} flag set.</p>

     *

     * @param property  accessor property to rebind

     * @param delegate  delegate object to rebind receiver to

     */

    AccessorProperty(final AccessorProperty property, final Object delegate) {

        super(property, property.getFlags() | IS_BOUND);

        this.primitiveGetter = bindTo(property.primitiveGetter, delegate);

        this.primitiveSetter = bindTo(property.primitiveSetter, delegate);

        this.objectGetter    = bindTo(property.objectGetter, delegate);

        this.objectSetter    = bindTo(property.objectSetter, delegate);

        property.GETTER_CACHE = new MethodHandle[NOOF_TYPES];

        // Properties created this way are bound to a delegate

        setType(property.getType());

    }

    /**

     * SPILL PROPERTY or USER ACCESSOR PROPERTY abstract constructor

     *

     * Constructor for spill properties. Array getters and setters will be created on demand.

     *

     * @param key    the property key

     * @param flags  the property flags

     * @param slot   spill slot

     * @param primitiveGetter primitive getter

     * @param primitiveSetter primitive setter

     * @param objectGetter    object getter

     * @param objectSetter    object setter

     */

    protected AccessorProperty(

            final Object key,

            final int flags,

            final int slot,

            final MethodHandle primitiveGetter,

            final MethodHandle primitiveSetter,

            final MethodHandle objectGetter,

            final MethodHandle objectSetter) {

        super(key, flags, slot);

        assert getClass() != AccessorProperty.class;

        this.primitiveGetter = primitiveGetter;

        this.primitiveSetter = primitiveSetter;

        this.objectGetter    = objectGetter;

        this.objectSetter    = objectSetter;

        initializeType();

    }

    /**

     * NASGEN constructor

     *

     * Constructor. Similar to the constructor with both primitive getters and setters, the difference

     * here being that only one getter and setter (setter is optional for non writable fields) is given

     * to the constructor, and the rest are created from those. Used e.g. by Nasgen classes

     *

     * @param key    the property key

     * @param flags  the property flags

     * @param slot   the property field number or spill slot

     * @param getter the property getter

     * @param setter the property setter or null if non writable, non configurable

     */

    private AccessorProperty(final Object key, final int flags, final int slot, final MethodHandle getter, final MethodHandle setter) {

        super(key, flags | IS_BUILTIN | DUAL_FIELDS | (getter.type().returnType().isPrimitive() ? IS_NASGEN_PRIMITIVE : 0), slot);

        assert !isSpill();

        // we don't need to prep the setters these will never be invalidated as this is a nasgen

        // or known type getter/setter. No invalidations will take place

        final Class<?> getterType = getter.type().returnType();

        final Class<?> setterType = setter == null ? null : setter.type().parameterType(1);

        assert setterType == null || setterType == getterType;

        if (getterType == int.class) {

            primitiveGetter = MH.asType(getter, Lookup.GET_PRIMITIVE_TYPE);

            primitiveSetter = setter == null ? null : MH.asType(setter, Lookup.SET_PRIMITIVE_TYPE);

        } else if (getterType == double.class) {

            primitiveGetter = MH.asType(MH.filterReturnValue(getter, ObjectClassGenerator.PACK_DOUBLE), Lookup.GET_PRIMITIVE_TYPE);

            primitiveSetter = setter == null ? null : MH.asType(MH.filterArguments(setter, 1, ObjectClassGenerator.UNPACK_DOUBLE), Lookup.SET_PRIMITIVE_TYPE);

        } else {

            primitiveGetter = primitiveSetter = null;

        }

        assert primitiveGetter == null || primitiveGetter.type() == Lookup.GET_PRIMITIVE_TYPE : primitiveGetter + "!=" + Lookup.GET_PRIMITIVE_TYPE;

        assert primitiveSetter == null || primitiveSetter.type() == Lookup.SET_PRIMITIVE_TYPE : primitiveSetter;

        objectGetter  = getter.type() != Lookup.GET_OBJECT_TYPE ? MH.asType(getter, Lookup.GET_OBJECT_TYPE) : getter;

        objectSetter  = setter != null && setter.type() != Lookup.SET_OBJECT_TYPE ? MH.asType(setter, Lookup.SET_OBJECT_TYPE) : setter;

        setType(getterType);

    }

    /**

     * Normal ACCESS PROPERTY constructor given a structure class.

     * Constructor for dual field AccessorPropertys.

     *

     * @param key              property key

     * @param flags            property flags

     * @param structure        structure for objects associated with this property

     * @param slot             property field number or spill slot

     */

    public AccessorProperty(final Object key, final int flags, final Class<?> structure, final int slot) {

        super(key, flags, slot);

        initGetterSetter(structure);

        initializeType();

    }

    private void initGetterSetter(final Class<?> structure) {

        final int slot = getSlot();

        /*

         * primitiveGetter and primitiveSetter are only used in dual fields mode. Setting them to null also

         * works in dual field mode, it only means that the property never has a primitive

         * representation.

         */

        if (isParameter() && hasArguments()) {

            //parameters are always stored in an object array, which may or may not be a good idea

            final MethodHandle arguments = MH.getter(LOOKUP, structure, "arguments", ScriptObject.class);

            objectGetter = MH.asType(MH.insertArguments(MH.filterArguments(ScriptObject.GET_ARGUMENT.methodHandle(), 0, arguments), 1, slot), Lookup.GET_OBJECT_TYPE);

            objectSetter = MH.asType(MH.insertArguments(MH.filterArguments(ScriptObject.SET_ARGUMENT.methodHandle(), 0, arguments), 1, slot), Lookup.SET_OBJECT_TYPE);

            primitiveGetter = null;

            primitiveSetter = null;

        } else {

            final Accessors gs = GETTERS_SETTERS.get(structure);

            objectGetter    = gs.objectGetters[slot];

            primitiveGetter = gs.primitiveGetters[slot];

            objectSetter    = gs.objectSetters[slot];

            primitiveSetter = gs.primitiveSetters[slot];

        }

        // Always use dual fields except for single field structures

        assert hasDualFields() != StructureLoader.isSingleFieldStructure(structure.getName());

    }

    /**

     * Constructor

     *

     * @param key          key

     * @param flags        flags

     * @param slot         field slot index

     * @param owner        owner of property

     * @param initialValue initial value to which the property can be set

     */

    protected AccessorProperty(final Object key, final int flags, final int slot, final ScriptObject owner, final Object initialValue) {

        this(key, flags, owner.getClass(), slot);

        setInitialValue(owner, initialValue);

    }

    /**

     * Normal access property constructor that overrides the type

     * Override the initial type. Used for Object Literals

     *

     * @param key          key

     * @param flags        flags

     * @param structure    structure to JO subclass

     * @param slot         field slot index

     * @param initialType  initial type of the property

     */

    public AccessorProperty(final Object key, final int flags, final Class<?> structure, final int slot, final Class<?> initialType) {

        this(key, flags, structure, slot);

        setType(hasDualFields() ? initialType : Object.class);

    }

    /**

     * Copy constructor that may change type and in that case clear the cache. Important to do that before

     * type change or getters will be created already stale.

     *

     * @param property property

     * @param newType  new type

     */

    protected AccessorProperty(final AccessorProperty property, final Class<?> newType) {

        super(property, property.getFlags());

        this.GETTER_CACHE    = newType != property.getLocalType() ? new MethodHandle[NOOF_TYPES] : property.GETTER_CACHE;

        this.primitiveGetter = property.primitiveGetter;

        this.primitiveSetter = property.primitiveSetter;

        this.objectGetter    = property.objectGetter;

        this.objectSetter    = property.objectSetter;

        setType(newType);

    }

    /**

     * COPY constructor

     *

     * @param property  source property

     */

    protected AccessorProperty(final AccessorProperty property) {

        this(property, property.getLocalType());

    }

    /**

     * Set initial value of a script object's property

     * @param owner        owner

     * @param initialValue initial value

     */

    protected final void setInitialValue(final ScriptObject owner, final Object initialValue) {

        setType(hasDualFields() ? JSType.unboxedFieldType(initialValue) : Object.class);

        if (initialValue instanceof Integer) {

            invokeSetter(owner, ((Integer)initialValue).intValue());

        } else if (initialValue instanceof Double) {

            invokeSetter(owner, ((Double)initialValue).doubleValue());

        } else {

            invokeSetter(owner, initialValue);

        }

    }

    /**

     * Initialize the type of a property

     */

    protected final void initializeType() {

        setType(!hasDualFields() ? Object.class : null);

    }

    private void readObject(final ObjectInputStream s) throws IOException, ClassNotFoundException {

        s.defaultReadObject();

        // Restore getters array

        GETTER_CACHE = new MethodHandle[NOOF_TYPES];

    }

    private static MethodHandle bindTo(final MethodHandle mh, final Object receiver) {

        if (mh == null) {

            return null;

        }

        return MH.dropArguments(MH.bindTo(mh, receiver), 0, Object.class);

    }

    @Override

    public Property copy() {

        return new AccessorProperty(this);

    }

    @Override

    public Property copy(final Class<?> newType) {

        return new AccessorProperty(this, newType);

    }

    @Override

    public int getIntValue(final ScriptObject self, final ScriptObject owner) {

        try {

            return (int)getGetter(int.class).invokeExact((Object)self);

        } catch (final Error | RuntimeException e) {

            throw e;

        } catch (final Throwable e) {

            throw new RuntimeException(e);

        }

     }

     @Override

     public double getDoubleValue(final ScriptObject self, final ScriptObject owner) {

        try {

            return (double)getGetter(double.class).invokeExact((Object)self);

        } catch (final Error | RuntimeException e) {

            throw e;

        } catch (final Throwable e) {

            throw new RuntimeException(e);

        }

    }

     @Override

     public Object getObjectValue(final ScriptObject self, final ScriptObject owner) {

        try {

            return getGetter(Object.class).invokeExact((Object)self);

        } catch (final Error | RuntimeException e) {

            throw e;

        } catch (final Throwable e) {

            throw new RuntimeException(e);

        }

    }

     /**

      * Invoke setter for this property with a value

      * @param self  owner

      * @param value value

      */

    protected final void invokeSetter(final ScriptObject self, final int value) {

        try {

            getSetter(int.class, self.getMap()).invokeExact((Object)self, value);

        } catch (final Error | RuntimeException e) {

            throw e;

        } catch (final Throwable e) {

            throw new RuntimeException(e);

        }

    }

    /**

     * Invoke setter for this property with a value

     * @param self  owner

     * @param value value

     */

    protected final void invokeSetter(final ScriptObject self, final double value) {

        try {

            getSetter(double.class, self.getMap()).invokeExact((Object)self, value);

        } catch (final Error | RuntimeException e) {

            throw e;

        } catch (final Throwable e) {

            throw new RuntimeException(e);

        }

    }

    /**

     * Invoke setter for this property with a value

     * @param self  owner

     * @param value value

     */

    protected final void invokeSetter(final ScriptObject self, final Object value) {

        try {

            getSetter(Object.class, self.getMap()).invokeExact((Object)self, value);

        } catch (final Error | RuntimeException e) {

            throw e;

        } catch (final Throwable e) {

            throw new RuntimeException(e);

        }

    }

    @Override

    public void setValue(final ScriptObject self, final ScriptObject owner, final int value, final boolean strict)  {

        assert isConfigurable() || isWritable() : getKey() + " is not writable or configurable";

        invokeSetter(self, value);

    }

    @Override

    public void setValue(final ScriptObject self, final ScriptObject owner, final double value, final boolean strict)  {

        assert isConfigurable() || isWritable() : getKey() + " is not writable or configurable";

        invokeSetter(self, value);

    }

    @Override

    public void setValue(final ScriptObject self, final ScriptObject owner, final Object value, final boolean strict)  {

        //this is sometimes used for bootstrapping, hence no assert. ugly.

        invokeSetter(self, value);

    }

    @Override

    void initMethodHandles(final Class<?> structure) {

        // sanity check for structure class

        if (!ScriptObject.class.isAssignableFrom(structure) || !StructureLoader.isStructureClass(structure.getName())) {

            throw new IllegalArgumentException();

        }