/*

 * Copyright (c) 2010, 2016, 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.objects;

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

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

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

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

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

import static jdk.nashorn.internal.runtime.arrays.ArrayLikeIterator.arrayLikeIterator;

import static jdk.nashorn.internal.runtime.arrays.ArrayLikeIterator.reverseArrayLikeIterator;

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

import java.lang.invoke.MethodHandle;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import java.util.concurrent.Callable;

import jdk.dynalink.CallSiteDescriptor;

import jdk.dynalink.linker.GuardedInvocation;

import jdk.dynalink.linker.LinkRequest;

import jdk.nashorn.api.scripting.JSObject;

import jdk.nashorn.internal.objects.annotations.Attribute;

import jdk.nashorn.internal.objects.annotations.Constructor;

import jdk.nashorn.internal.objects.annotations.Function;

import jdk.nashorn.internal.objects.annotations.Getter;

import jdk.nashorn.internal.objects.annotations.ScriptClass;

import jdk.nashorn.internal.objects.annotations.Setter;

import jdk.nashorn.internal.objects.annotations.SpecializedFunction;

import jdk.nashorn.internal.objects.annotations.SpecializedFunction.LinkLogic;

import jdk.nashorn.internal.objects.annotations.Where;

import jdk.nashorn.internal.runtime.Context;

import jdk.nashorn.internal.runtime.Debug;

import jdk.nashorn.internal.runtime.JSType;

import jdk.nashorn.internal.runtime.OptimisticBuiltins;

import jdk.nashorn.internal.runtime.PropertyDescriptor;

import jdk.nashorn.internal.runtime.PropertyMap;

import jdk.nashorn.internal.runtime.ScriptObject;

import jdk.nashorn.internal.runtime.ScriptRuntime;

import jdk.nashorn.internal.runtime.Undefined;

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

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

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

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

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

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

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

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

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

/**

 * Runtime representation of a JavaScript array. NativeArray only holds numeric

 * keyed values. All other values are stored in spill.

 */

@ScriptClass("Array")

public final class NativeArray extends ScriptObject implements OptimisticBuiltins {

    private static final Object JOIN                     = new Object();

    private static final Object EVERY_CALLBACK_INVOKER   = new Object();

    private static final Object SOME_CALLBACK_INVOKER    = new Object();

    private static final Object FOREACH_CALLBACK_INVOKER = new Object();

    private static final Object MAP_CALLBACK_INVOKER     = new Object();

    private static final Object FILTER_CALLBACK_INVOKER  = new Object();

    private static final Object REDUCE_CALLBACK_INVOKER  = new Object();

    private static final Object CALL_CMP                 = new Object();

    private static final Object TO_LOCALE_STRING         = new Object();

    /*

     * Constructors.

     */

    NativeArray() {

        this(ArrayData.initialArray());

    }

    NativeArray(final long length) {

        this(ArrayData.allocate(length));

    }

    NativeArray(final int[] array) {

        this(ArrayData.allocate(array));

    }

    NativeArray(final double[] array) {

        this(ArrayData.allocate(array));

    }

    NativeArray(final long[] array) {

        this(ArrayData.allocate(array.length));

        ArrayData arrayData = this.getArray();

        Class<?> widest = int.class;

        for (int index = 0; index < array.length; index++) {

            final long value = array[index];

            if (widest == int.class && JSType.isRepresentableAsInt(value)) {

                arrayData = arrayData.set(index, (int) value, false);

            } else if (widest != Object.class && JSType.isRepresentableAsDouble(value)) {

                arrayData = arrayData.set(index, (double) value, false);

                widest = double.class;

            } else {

                arrayData = arrayData.set(index, (Object) value, false);

                widest = Object.class;

            }

        }

        this.setArray(arrayData);

    }

    NativeArray(final Object[] array) {

        this(ArrayData.allocate(array.length));

        ArrayData arrayData = this.getArray();

        for (int index = 0; index < array.length; index++) {

            final Object value = array[index];

            if (value == ScriptRuntime.EMPTY) {

                arrayData = arrayData.delete(index);

            } else {

                arrayData = arrayData.set(index, value, false);

            }

        }

        this.setArray(arrayData);

    }

    NativeArray(final ArrayData arrayData) {

        this(arrayData, Global.instance());

    }

    NativeArray(final ArrayData arrayData, final Global global) {

        super(global.getArrayPrototype(), $nasgenmap$);

        setArray(arrayData);

        setIsArray();

    }

    @Override

    protected GuardedInvocation findGetIndexMethod(final CallSiteDescriptor desc, final LinkRequest request) {

        final GuardedInvocation inv = getArray().findFastGetIndexMethod(getArray().getClass(), desc, request);

        if (inv != null) {

            return inv;

        }

        return super.findGetIndexMethod(desc, request);

    }

    @Override

    protected GuardedInvocation findSetIndexMethod(final CallSiteDescriptor desc, final LinkRequest request) {

        final GuardedInvocation inv = getArray().findFastSetIndexMethod(getArray().getClass(), desc, request);

        if (inv != null) {

            return inv;

        }

        return super.findSetIndexMethod(desc, request);

    }

    private static InvokeByName getJOIN() {

        return Global.instance().getInvokeByName(JOIN,

                new Callable<InvokeByName>() {

                    @Override

                    public InvokeByName call() {

                        return new InvokeByName("join", ScriptObject.class);

                    }

                });

    }

    private static MethodHandle createIteratorCallbackInvoker(final Object key, final Class<?> rtype) {

        return Global.instance().getDynamicInvoker(key,

            new Callable<MethodHandle>() {

                @Override

                public MethodHandle call() {

                    return Bootstrap.createDynamicCallInvoker(rtype, Object.class, Object.class, Object.class,

                        double.class, Object.class);

                }

            });

    }

    private static MethodHandle getEVERY_CALLBACK_INVOKER() {

        return createIteratorCallbackInvoker(EVERY_CALLBACK_INVOKER, boolean.class);

    }

    private static MethodHandle getSOME_CALLBACK_INVOKER() {

        return createIteratorCallbackInvoker(SOME_CALLBACK_INVOKER, boolean.class);

    }

    private static MethodHandle getFOREACH_CALLBACK_INVOKER() {

        return createIteratorCallbackInvoker(FOREACH_CALLBACK_INVOKER, void.class);

    }

    private static MethodHandle getMAP_CALLBACK_INVOKER() {

        return createIteratorCallbackInvoker(MAP_CALLBACK_INVOKER, Object.class);

    }

    private static MethodHandle getFILTER_CALLBACK_INVOKER() {

        return createIteratorCallbackInvoker(FILTER_CALLBACK_INVOKER, boolean.class);

    }

    private static MethodHandle getREDUCE_CALLBACK_INVOKER() {

        return Global.instance().getDynamicInvoker(REDUCE_CALLBACK_INVOKER,

                new Callable<MethodHandle>() {

                    @Override

                    public MethodHandle call() {

                        return Bootstrap.createDynamicCallInvoker(Object.class, Object.class,

                             Undefined.class, Object.class, Object.class, double.class, Object.class);

                    }

                });

    }

    private static MethodHandle getCALL_CMP() {

        return Global.instance().getDynamicInvoker(CALL_CMP,

                new Callable<MethodHandle>() {

                    @Override

                    public MethodHandle call() {

                        return Bootstrap.createDynamicCallInvoker(double.class,

                            Object.class, Object.class, Object.class, Object.class);

                    }

                });

    }

    private static InvokeByName getTO_LOCALE_STRING() {

        return Global.instance().getInvokeByName(TO_LOCALE_STRING,

                new Callable<InvokeByName>() {

                    @Override

                    public InvokeByName call() {

                        return new InvokeByName("toLocaleString", ScriptObject.class, String.class);

                    }

                });

    }

    // initialized by nasgen

    private static PropertyMap $nasgenmap$;

    @Override

    public String getClassName() {

        return "Array";

    }

    @Override

    public Object getLength() {

        final long length = getArray().length();

        assert length >= 0L;

        if (length <= Integer.MAX_VALUE) {

            return (int)length;

        }

        return length;

    }

    private boolean defineLength(final long oldLen, final PropertyDescriptor oldLenDesc, final PropertyDescriptor desc, final boolean reject) {

        // Step 3a

        if (!desc.has(VALUE)) {

            return super.defineOwnProperty("length", desc, reject);

        }

        // Step 3b

        final PropertyDescriptor newLenDesc = desc;

        // Step 3c and 3d - get new length and convert to long

        final long newLen = NativeArray.validLength(newLenDesc.getValue());

        // Step 3e - note that we need to convert to int or double as long is not considered a JS number type anymore

        newLenDesc.setValue(JSType.toNarrowestNumber(newLen));

        // Step 3f

        // increasing array length - just need to set new length value (and attributes if any) and return

        if (newLen >= oldLen) {

            return super.defineOwnProperty("length", newLenDesc, reject);

        }

        // Step 3g

        if (!oldLenDesc.isWritable()) {

            if (reject) {

                throw typeError("property.not.writable", "length", ScriptRuntime.safeToString(this));

            }

            return false;

        }

        // Step 3h and 3i

        final boolean newWritable = !newLenDesc.has(WRITABLE) || newLenDesc.isWritable();

        if (!newWritable) {

            newLenDesc.setWritable(true);

        }

        // Step 3j and 3k

        final boolean succeeded = super.defineOwnProperty("length", newLenDesc, reject);

        if (!succeeded) {

            return false;

        }

        // Step 3l

        // make sure that length is set till the point we can delete the old elements

        long o = oldLen;

        while (newLen < o) {

            o--;

            final boolean deleteSucceeded = delete(o, false);

            if (!deleteSucceeded) {

                newLenDesc.setValue(o + 1);

                if (!newWritable) {

                    newLenDesc.setWritable(false);

                }

                super.defineOwnProperty("length", newLenDesc, false);

                if (reject) {

                    throw typeError("property.not.writable", "length", ScriptRuntime.safeToString(this));

                }

                return false;

            }

        }

        // Step 3m

        if (!newWritable) {

            // make 'length' property not writable

            final ScriptObject newDesc = Global.newEmptyInstance();

            newDesc.set(WRITABLE, false, 0);

            return super.defineOwnProperty("length", newDesc, false);

        }

        return true;

    }

    /**

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

     */

    @Override

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

        final PropertyDescriptor desc = toPropertyDescriptor(Global.instance(), propertyDesc);

        // never be undefined as "length" is always defined and can't be deleted for arrays

        // Step 1

        final PropertyDescriptor oldLenDesc = (PropertyDescriptor) super.getOwnPropertyDescriptor("length");

        // Step 2

        // get old length and convert to long. Always a Long/Uint32 but we take the safe road.

        final long oldLen = JSType.toUint32(oldLenDesc.getValue());

        // Step 3

        if ("length".equals(key)) {

            // check for length being made non-writable

            final boolean result = defineLength(oldLen, oldLenDesc, desc, reject);

            if (desc.has(WRITABLE) && !desc.isWritable()) {

                setIsLengthNotWritable();

            }

            return result;

        }

        // Step 4a

        final int index = ArrayIndex.getArrayIndex(key);

        if (ArrayIndex.isValidArrayIndex(index)) {

            final long longIndex = ArrayIndex.toLongIndex(index);

            // Step 4b

            // setting an element beyond current length, but 'length' is not writable

            if (longIndex >= oldLen && !oldLenDesc.isWritable()) {

                if (reject) {

                    throw typeError("property.not.writable", Long.toString(longIndex), ScriptRuntime.safeToString(this));

                }

                return false;

            }

            // Step 4c

            // set the new array element

            final boolean succeeded = super.defineOwnProperty(key, desc, false);

            // Step 4d

            if (!succeeded) {

                if (reject) {

                    throw typeError("cant.redefine.property", key.toString(), ScriptRuntime.safeToString(this));

                }

                return false;

            }

            // Step 4e -- adjust new length based on new element index that is set

            if (longIndex >= oldLen) {

                oldLenDesc.setValue(longIndex + 1);

                super.defineOwnProperty("length", oldLenDesc, false);

            }

            // Step 4f

            return true;

        }

        // not an index property

        return super.defineOwnProperty(key, desc, reject);

    }

    /**

     * Spec. mentions use of [[DefineOwnProperty]] for indexed properties in

     * certain places (eg. Array.prototype.map, filter). We can not use ScriptObject.set

     * method in such cases. This is because set method uses inherited setters (if any)

     * from any object in proto chain such as Array.prototype, Object.prototype.

     * This method directly sets a particular element value in the current object.

     *

     * @param index key for property

     * @param value value to define

     */

    @Override

    public final void defineOwnProperty(final int index, final Object value) {

        assert isValidArrayIndex(index) : "invalid array index";

        final long longIndex = ArrayIndex.toLongIndex(index);

        if (longIndex >= getArray().length()) {

            // make array big enough to hold..

            setArray(getArray().ensure(longIndex));

        }

        setArray(getArray().set(index, value, false));

    }

    /**

     * Return the array contents upcasted as an ObjectArray, regardless of

     * representation

     *

     * @return an object array

     */

    public Object[] asObjectArray() {

        return getArray().asObjectArray();

    }

    @Override

    public void setIsLengthNotWritable() {

        super.setIsLengthNotWritable();

        setArray(ArrayData.setIsLengthNotWritable(getArray()));

    }

    /**

     * ECMA 15.4.3.2 Array.isArray ( arg )

     *

     * @param self self reference

     * @param arg  argument - object to check

     * @return true if argument is an array

     */

    @Function(attributes = Attribute.NOT_ENUMERABLE, where = Where.CONSTRUCTOR)

    public static boolean isArray(final Object self, final Object arg) {

        return isArray(arg) || (arg instanceof JSObject && ((JSObject)arg).isArray());

    }

    /**

     * Length getter

     * @param self self reference

     * @return the length of the object

     */

    @Getter(attributes = Attribute.NOT_ENUMERABLE | Attribute.NOT_CONFIGURABLE)

    public static Object length(final Object self) {

        if (isArray(self)) {

            final long length = ((ScriptObject) self).getArray().length();

            assert length >= 0L;

            // Cast to the narrowest supported numeric type to help optimistic type calculator

            if (length <= Integer.MAX_VALUE) {

                return (int) length;

            }

            return (double) length;

        }

        return 0;

    }

    /**

     * Length setter

     * @param self   self reference

     * @param length new length property

     */

    @Setter(attributes = Attribute.NOT_ENUMERABLE | Attribute.NOT_CONFIGURABLE)

    public static void length(final Object self, final Object length) {

        if (isArray(self)) {

            ((ScriptObject)self).setLength(validLength(length));

        }

    }

    /**

     * Prototype length getter

     * @param self self reference

     * @return the length of the object

     */

    @Getter(name = "length", where = Where.PROTOTYPE, attributes = Attribute.NOT_ENUMERABLE | Attribute.NOT_CONFIGURABLE)

    public static Object getProtoLength(final Object self) {

        return length(self);  // Same as instance getter but we can't make nasgen use the same method for prototype

    }

    /**

     * Prototype length setter