/*

 * 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.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.ArrayLikeIterator.arrayLikeIterator;

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

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 jdk.nashorn.api.scripting.ScriptObjectMirror;

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.SpecializedConstructor;

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

import jdk.nashorn.internal.runtime.JSType;

import jdk.nashorn.internal.runtime.PropertyDescriptor;

import jdk.nashorn.internal.runtime.PropertyMap;

import jdk.nashorn.internal.runtime.ScriptFunction;

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.IteratorAction;

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 {

    private static final InvokeByName JOIN = new InvokeByName("join", ScriptObject.class);

    private static final MethodHandle EVERY_CALLBACK_INVOKER   = createIteratorCallbackInvoker(boolean.class);

    private static final MethodHandle SOME_CALLBACK_INVOKER    = createIteratorCallbackInvoker(boolean.class);

    private static final MethodHandle FOREACH_CALLBACK_INVOKER = createIteratorCallbackInvoker(void.class);

    private static final MethodHandle MAP_CALLBACK_INVOKER     = createIteratorCallbackInvoker(Object.class);

    private static final MethodHandle FILTER_CALLBACK_INVOKER  = createIteratorCallbackInvoker(boolean.class);

    private static final MethodHandle REDUCE_CALLBACK_INVOKER = Bootstrap.createDynamicInvoker("dyn:call", Object.class,

            Object.class, Undefined.class, Object.class, Object.class, long.class, Object.class);

    private static final MethodHandle CALL_CMP                = Bootstrap.createDynamicInvoker("dyn:call", double.class,

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

    private static final InvokeByName TO_LOCALE_STRING = new InvokeByName("toLocaleString", ScriptObject.class, String.class);

    // initialized by nasgen

    private static PropertyMap $nasgenmap$;

    static PropertyMap getInitialMap() {

        return $nasgenmap$;

    }

    /*

     * Constructors.

     */

    NativeArray() {

        this(ArrayData.initialArray());

    }

    NativeArray(final long length) {

        // TODO assert valid index in long before casting

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

    }

    NativeArray(final int[] array) {

        this(ArrayData.allocate(array));

    }

    NativeArray(final long[] array) {

        this(ArrayData.allocate(array));

    }

    NativeArray(final double[] array) {

        this(ArrayData.allocate(array));

    }

    NativeArray(final Object[] array) {

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

        ArrayData arrayData = this.getArray();

        arrayData.ensure(array.length - 1);

        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(), global.getArrayMap());

        this.setArray(arrayData);

        this.setIsArray();

    }

    @Override

    public String getClassName() {

        return "Array";

    }

    @Override

    public Object getLength() {

        return getArray().length() & JSType.MAX_UINT;

    }

    /**

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

     */

    @Override

    public boolean defineOwnProperty(final String 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

        long oldLen = NativeArray.validLength(oldLenDesc.getValue(), true);

        // Step 3

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

            // check for length being made non-writable

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

                setIsLengthNotWritable();

            }

            // 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(), true);

            // Step 3e

            newLenDesc.setValue(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

            while (newLen < oldLen) {

                oldLen--;

                final boolean deleteSucceeded = delete(oldLen, false);

                if (!deleteSucceeded) {

                    newLenDesc.setValue(oldLen + 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, false);

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

            }

            return true;

        }

        // 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, 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);

    }

    /**

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

     * representation

     *

     * @return an object array

     */

    public Object[] asObjectArray() {

        return getArray().asObjectArray();

    }

    /**

     * 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 Object isArray(final Object self, final Object arg) {

        return isArray(arg) || (arg == Global.instance().getArrayPrototype())

                || (arg instanceof NativeRegExpExecResult)

                || (arg instanceof ScriptObjectMirror && ((ScriptObjectMirror)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)) {

            return ((ScriptObject) self).getArray().length() & JSType.MAX_UINT;

        }

        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, true));

        }

    }

    static long validLength(final Object length, final boolean reject) {

        final double doubleLength = JSType.toNumber(length);

        if (!Double.isNaN(doubleLength) && JSType.isRepresentableAsLong(doubleLength)) {

            final long len = (long) doubleLength;

            if (len >= 0 && len <= JSType.MAX_UINT) {

                return len;

            }

        }

        if (reject) {

            throw rangeError("inappropriate.array.length", ScriptRuntime.safeToString(length));

        }

        return -1;

    }

    /**

     * ECMA 15.4.4.2 Array.prototype.toString ( )

     *

     * @param self self reference

     * @return string representation of array

     */

    @Function(attributes = Attribute.NOT_ENUMERABLE)

    public static Object toString(final Object self) {

        final Object obj = Global.toObject(self);

        if (obj instanceof ScriptObject) {

            final ScriptObject sobj = (ScriptObject)obj;

            try {

                final Object join = JOIN.getGetter().invokeExact(sobj);

                if (join instanceof ScriptFunction) {

                    return JOIN.getInvoker().invokeExact(join, sobj);

                }

            } catch (final RuntimeException | Error e) {

                throw e;

            } catch (final Throwable t) {

                throw new RuntimeException(t);

            }

        }

        // FIXME: should lookup Object.prototype.toString and call that?

        return ScriptRuntime.builtinObjectToString(self);

    }

    /**

     * ECMA 15.4.4.3 Array.prototype.toLocaleString ( )

     *

     * @param self self reference

     * @return locale specific string representation for array

     */

    @Function(attributes = Attribute.NOT_ENUMERABLE)

    public static Object toLocaleString(final Object self) {

        final StringBuilder sb = new StringBuilder();

        final Iterator<Object> iter = arrayLikeIterator(self, true);

        while (iter.hasNext()) {

            final Object obj = iter.next();

            if (obj != null && obj != ScriptRuntime.UNDEFINED) {

                final Object val = JSType.toScriptObject(obj);

                try {

                    if (val instanceof ScriptObject) {

                        final ScriptObject sobj           = (ScriptObject)val;

                        final Object       toLocaleString = TO_LOCALE_STRING.getGetter().invokeExact(sobj);

                        if (toLocaleString instanceof ScriptFunction) {

                            sb.append((String)TO_LOCALE_STRING.getInvoker().invokeExact(toLocaleString, sobj));

                        } else {

                            throw typeError("not.a.function", "toLocaleString");

                        }

                    }

                } catch (final Error|RuntimeException t) {

                    throw t;

                } catch (final Throwable t) {

                    throw new RuntimeException(t);

                }

            }

            if (iter.hasNext()) {

                sb.append(",");

            }

        }

        return sb.toString();

    }

    /**

     * ECMA 15.4.2.2 new Array (len)

     *

     * @param newObj was the new operator used to instantiate this array

     * @param self   self reference

     * @param args   arguments (length)

     * @return the new NativeArray

     */

    @Constructor(arity = 1)

    public static Object construct(final boolean newObj, final Object self, final Object... args) {

        switch (args.length) {

        case 0:

            return new NativeArray(0);

        case 1:

            final Object len = args[0];

            if (len instanceof Number) {

                long length;

                if (len instanceof Integer || len instanceof Long) {

                    length = ((Number) len).longValue();

                    if (length >= 0 && length < JSType.MAX_UINT) {

                        return new NativeArray(length);

                    }

                }

                length = JSType.toUint32(len);

                /*

                 * If the argument len is a Number and ToUint32(len) is equal to

                 * len, then the length property of the newly constructed object

                 * is set to ToUint32(len). If the argument len is a Number and

                 * ToUint32(len) is not equal to len, a RangeError exception is

                 * thrown.

                 */

                final double numberLength = ((Number) len).doubleValue();

                if (length != numberLength) {

                    throw rangeError("inappropriate.array.length", JSType.toString(numberLength));

                }

                return new NativeArray(length);

            }

            /*

             * If the argument len is not a Number, then the length property of

             * the newly constructed object is set to 1 and the 0 property of

             * the newly constructed object is set to len

             */

            return new NativeArray(new Object[]{args[0]});

            //fallthru

        default:

            return new NativeArray(args);

        }

    }

    /**

     * ECMA 15.4.2.2 new Array (len)

     *

     * Specialized constructor for zero arguments - empty array

     *

     * @param newObj was the new operator used to instantiate this array

     * @param self   self reference

     * @return the new NativeArray

     */

    @SpecializedConstructor

    public static Object construct(final boolean newObj, final Object self) {

        return new NativeArray(0);

    }

    /**

     * ECMA 15.4.2.2 new Array (len)

     *

     * Specialized constructor for one integer argument (length)

     *

     * @param newObj was the new operator used to instantiate this array

     * @param self   self reference

     * @param length array length

     * @return the new NativeArray

     */

    @SpecializedConstructor

    public static Object construct(final boolean newObj, final Object self, final int length) {

        if (length >= 0) {

            return new NativeArray(length);

        }

        return construct(newObj, self, new Object[]{length});

    }

    /**

     * ECMA 15.4.2.2 new Array (len)

     *

     * Specialized constructor for one long argument (length)

     *

     * @param newObj was the new operator used to instantiate this array

     * @param self   self reference

     * @param length array length

     * @return the new NativeArray

     */

    @SpecializedConstructor

    public static Object construct(final boolean newObj, final Object self, final long length) {

        if (length >= 0L && length <= JSType.MAX_UINT) {

            return new NativeArray(length);

        }

        return construct(newObj, self, new Object[]{length});

    }