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

import static jdk.nashorn.internal.codegen.CompilerConstants.staticCall;
import static jdk.nashorn.internal.lookup.Lookup.MH;
import static jdk.nashorn.internal.runtime.JSType.getAccessorTypeIndex;
import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.INVALID_PROGRAM_POINT;
import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.isValid;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.SwitchPoint;
import jdk.dynalink.CallSiteDescriptor;
import jdk.dynalink.linker.GuardedInvocation;
import jdk.dynalink.linker.LinkRequest;
import jdk.nashorn.internal.codegen.types.Type;
import jdk.nashorn.internal.lookup.Lookup;
import jdk.nashorn.internal.runtime.ScriptObject;
import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
import jdk.nashorn.internal.runtime.logging.Logger;

Interface implemented by all arrays that are directly accessible as underlying
native arrays
/**
 * Interface implemented by all arrays that are directly accessible as underlying
 * native arrays
 */
@Logger(name="arrays")
public abstract class ContinuousArrayData extends ArrayData {
    
Constructor
Params:
length – length (elementLength)/**
     * Constructor
     * @param length length (elementLength)
     */
    protected ContinuousArrayData(final long length) {
        super(length);
    }

    
Check if we can put one more element at the end of this continuous
array without reallocating, or if we are overwriting an already
allocated element
Params:
index – index to check
Returns:
true if we don't need to do any array reallocation to fit an element at index/**
     * Check if we can put one more element at the end of this continuous
     * array without reallocating, or if we are overwriting an already
     * allocated element
     *
     * @param index index to check
     * @return true if we don't need to do any array reallocation to fit an element at index
     */
    public final boolean hasRoomFor(final int index) {
        return has(index) || (index == length() && ensure(index) == this);
    }

    
Check if an arraydata is empty
Returns:
true if empty/**
     * Check if an arraydata is empty
     * @return true if empty
     */
    public boolean isEmpty() {
        return length() == 0L;
    }

    
Return element getter for a certain type at a certain program point
Params:
returnType –   return type
programPoint – program point
Returns:
element getter or null if not supported (used to implement slow linkage instead
  as fast isn't possible)/**
     * Return element getter for a certain type at a certain program point
     * @param returnType   return type
     * @param programPoint program point
     * @return element getter or null if not supported (used to implement slow linkage instead
     *   as fast isn't possible)
     */
    public abstract MethodHandle getElementGetter(final Class<?> returnType, final int programPoint);

    
Return element getter for a certain type at a certain program point
Params:
elementType – element type
Returns:
element setter or null if not supported (used to implement slow linkage instead
  as fast isn't possible)/**
     * Return element getter for a certain type at a certain program point
     * @param elementType element type
     * @return element setter or null if not supported (used to implement slow linkage instead
     *   as fast isn't possible)
     */
    public abstract MethodHandle getElementSetter(final Class<?> elementType);

    
Version of has that throws a class cast exception if element does not exist
used for relinking
Params:
index – index to check - currently only int indexes
Returns:
index/**
     * Version of has that throws a class cast exception if element does not exist
     * used for relinking
     *
     * @param index index to check - currently only int indexes
     * @return index
     */
    protected final int throwHas(final int index) {
        if (!has(index)) {
            throw new ClassCastException();
        }
        return index;
    }

    @Override
    public abstract ContinuousArrayData copy();

    
Returns the type used to store an element in this array
Returns:
element type/**
     * Returns the type used to store an element in this array
     * @return element type
     */
    public abstract Class<?> getElementType();

    @Override
    public Type getOptimisticType() {
        return Type.typeFor(getElementType());
    }

    
Returns the boxed type of the type used to store an element in this array
Returns:
element type/**
     * Returns the boxed type of the type used to store an element in this array
     * @return element type
     */
    public abstract Class<?> getBoxedElementType();

    
Get the widest element type of two arrays. This can be done faster in subclasses, but
this works for all ContinuousArrayDatas and for where more optimal checks haven't been
implemented.
Params:
otherData – another ContinuousArrayData
Returns:
the widest boxed element type/**
     * Get the widest element type of two arrays. This can be done faster in subclasses, but
     * this works for all ContinuousArrayDatas and for where more optimal checks haven't been
     * implemented.
     *
     * @param otherData another ContinuousArrayData
     * @return the widest boxed element type
     */
    public ContinuousArrayData widest(final ContinuousArrayData otherData) {
        final Class<?> elementType = getElementType();
        return Type.widest(elementType, otherData.getElementType()) == elementType ? this : otherData;
    }

    
Look up a continuous array element getter
Params:
get –          getter, sometimes combined with a has check that throws CCE on failure for relink
returnType –   return type
programPoint – program point
Returns:
array getter/**
     * Look up a continuous array element getter
     * @param get          getter, sometimes combined with a has check that throws CCE on failure for relink
     * @param returnType   return type
     * @param programPoint program point
     * @return array getter
     */
    protected final MethodHandle getContinuousElementGetter(final MethodHandle get, final Class<?> returnType, final int programPoint) {
        return getContinuousElementGetter(getClass(), get, returnType, programPoint);
    }

    
Look up a continuous array element setter
Params:
set –          setter, sometimes combined with a has check that throws CCE on failure for relink
returnType –   return type
Returns:
array setter/**
     * Look up a continuous array element setter
     * @param set          setter, sometimes combined with a has check that throws CCE on failure for relink
     * @param returnType   return type
     * @return array setter
     */
    protected final MethodHandle getContinuousElementSetter(final MethodHandle set, final Class<?> returnType) {
        return getContinuousElementSetter(getClass(), set, returnType);
    }

    
Return element getter for a ContinuousArrayData 
Params:
clazz –        clazz for exact type guard
getHas –       has getter
returnType –   return type
programPoint – program point
Returns:
method handle for element setter/**
     * Return element getter for a {@link ContinuousArrayData}
     * @param clazz        clazz for exact type guard
     * @param getHas       has getter
     * @param returnType   return type
     * @param programPoint program point
     * @return method handle for element setter
     */
    protected MethodHandle getContinuousElementGetter(final Class<? extends ContinuousArrayData> clazz, final MethodHandle getHas, final Class<?> returnType, final int programPoint) {
        final boolean isOptimistic = isValid(programPoint);
        final int     fti          = getAccessorTypeIndex(getHas.type().returnType());
        final int     ti           = getAccessorTypeIndex(returnType);
        MethodHandle  mh           = getHas;

        if (isOptimistic) {
            if (ti < fti) {
                mh = MH.insertArguments(ArrayData.THROW_UNWARRANTED.methodHandle(), 1, programPoint);
            }
        }
        mh = MH.asType(mh, mh.type().changeReturnType(returnType).changeParameterType(0, clazz));

        if (!isOptimistic) {
            //for example a & array[17];
            return Lookup.filterReturnType(mh, returnType);
        }
        return mh;
    }

    
Return element setter for a ContinuousArrayData 
Params:
clazz –        class for exact type guard
setHas –       set has guard
elementType –  element type
Returns:
method handle for element setter/**
     * Return element setter for a {@link ContinuousArrayData}
     * @param clazz        class for exact type guard
     * @param setHas       set has guard
     * @param elementType  element type
     * @return method handle for element setter
     */
    protected MethodHandle getContinuousElementSetter(final Class<? extends ContinuousArrayData> clazz, final MethodHandle setHas, final Class<?> elementType) {
        return MH.asType(setHas, setHas.type().changeParameterType(2, elementType).changeParameterType(0, clazz));
    }

    
Fast access guard - it is impractical for JIT performance reasons to use only CCE asType as guard :-(, also we need
the null case explicitly, which is the one that CCE doesn't handle /** Fast access guard - it is impractical for JIT performance reasons to use only CCE asType as guard :-(, also we need
      the null case explicitly, which is the one that CCE doesn't handle */
    protected static final MethodHandle FAST_ACCESS_GUARD =
            MH.dropArguments(
                    staticCall(
                            MethodHandles.lookup(),
                            ContinuousArrayData.class,
                            "guard",
                            boolean.class,
                            Class.class,
                            ScriptObject.class).methodHandle(),
                    2,
                    int.class);

    @SuppressWarnings("unused")
    private static boolean guard(final Class<? extends ContinuousArrayData> clazz, final ScriptObject sobj) {
        return sobj != null && sobj.getArray().getClass() == clazz;
    }

    
Return a fast linked array getter, or null if we have to dispatch to super class
Params:
desc –     descriptor
request –  link request
Returns:
invocation or null if needs to be sent to slow relink/**
     * Return a fast linked array getter, or null if we have to dispatch to super class
     * @param desc     descriptor
     * @param request  link request
     * @return invocation or null if needs to be sent to slow relink
     */
    @Override
    public GuardedInvocation findFastGetIndexMethod(final Class<? extends ArrayData> clazz, final CallSiteDescriptor desc, final LinkRequest request) {
        final MethodType callType   = desc.getMethodType();
        final Class<?>   indexType  = callType.parameterType(1);
        final Class<?>   returnType = callType.returnType();

        if (ContinuousArrayData.class.isAssignableFrom(clazz) && indexType == int.class) {
            final Object[] args  = request.getArguments();
            final int      index = (int)args[args.length - 1];

            if (has(index)) {
                final MethodHandle getArray     = ScriptObject.GET_ARRAY.methodHandle();
                final int          programPoint = NashornCallSiteDescriptor.isOptimistic(desc) ? NashornCallSiteDescriptor.getProgramPoint(desc) : INVALID_PROGRAM_POINT;
                MethodHandle       getElement   = getElementGetter(returnType, programPoint);
                if (getElement != null) {
                    getElement = MH.filterArguments(getElement, 0, MH.asType(getArray, getArray.type().changeReturnType(clazz)));
                    final MethodHandle guard = MH.insertArguments(FAST_ACCESS_GUARD, 0, clazz);
                    return new GuardedInvocation(getElement, guard, (SwitchPoint)null, ClassCastException.class);
                }
            }
        }

        return null;
    }

    
Return a fast linked array setter, or null if we have to dispatch to super class
Params:
desc –     descriptor
request –  link request
Returns:
invocation or null if needs to be sent to slow relink/**
     * Return a fast linked array setter, or null if we have to dispatch to super class
     * @param desc     descriptor
     * @param request  link request
     * @return invocation or null if needs to be sent to slow relink
     */
    @Override
    public GuardedInvocation findFastSetIndexMethod(final Class<? extends ArrayData> clazz, final CallSiteDescriptor desc, final LinkRequest request) { // array, index, value
        final MethodType callType    = desc.getMethodType();
        final Class<?>   indexType   = callType.parameterType(1);
        final Class<?>   elementType = callType.parameterType(2);

        if (ContinuousArrayData.class.isAssignableFrom(clazz) && indexType == int.class) {
            final Object[]        args  = request.getArguments();
            final int             index = (int)args[args.length - 2];

            if (hasRoomFor(index)) {
                MethodHandle setElement = getElementSetter(elementType); //Z(continuousarraydata, int, int), return true if successful
                if (setElement != null) {
                    //else we are dealing with a wider type than supported by this callsite
                    MethodHandle getArray = ScriptObject.GET_ARRAY.methodHandle();
                    getArray   = MH.asType(getArray, getArray.type().changeReturnType(getClass()));
                    setElement = MH.filterArguments(setElement, 0, getArray);
                    final MethodHandle guard = MH.insertArguments(FAST_ACCESS_GUARD, 0, clazz);
                    return new GuardedInvocation(setElement, guard, (SwitchPoint)null, ClassCastException.class); //CCE if not a scriptObject anymore
                }
            }
        }

        return null;
    }

    
Specialization - fast push implementation
Params:
arg – argument
Returns:
new array length/**
     * Specialization - fast push implementation
     * @param arg argument
     * @return new array length
     */
    public double fastPush(final int arg) {
        throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
    }

    
Specialization - fast push implementation
Params:
arg – argument
Returns:
new array length/**
     * Specialization - fast push implementation
     * @param arg argument
     * @return new array length
     */
    public double fastPush(final long arg) {
        throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
    }

    
Specialization - fast push implementation
Params:
arg – argument
Returns:
new array length/**
     * Specialization - fast push implementation
     * @param arg argument
     * @return new array length
     */
    public double fastPush(final double arg) {
        throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
    }

    
Specialization - fast push implementation
Params:
arg – argument
Returns:
new array length/**
     * Specialization - fast push implementation
     * @param arg argument
     * @return new array length
     */
    public double fastPush(final Object arg) {
        throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
    }

    
Specialization - fast pop implementation
Returns:
element value/**
     * Specialization - fast pop implementation
     * @return element value
     */
    public int fastPopInt() {
        throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
    }

    
Specialization - fast pop implementation
Returns:
element value/**
     * Specialization - fast pop implementation
     * @return element value
     */
    public double fastPopDouble() {
       throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
    }

    
Specialization - fast pop implementation
Returns:
element value/**
     * Specialization - fast pop implementation
     * @return element value
     */
    public Object fastPopObject() {
        throw new ClassCastException(String.valueOf(getClass())); //type is wrong, relink
    }

    
Specialization - fast concat implementation
Params:
otherData – data to concat
Returns:
new arraydata/**
     * Specialization - fast concat implementation
     * @param otherData data to concat
     * @return new arraydata
     */
    public ContinuousArrayData fastConcat(final ContinuousArrayData otherData) {
        throw new ClassCastException(String.valueOf(getClass()) + " != " + String.valueOf(otherData.getClass()));
    }
}