/*

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

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

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.nio.ByteBuffer;

import jdk.internal.dynalink.CallSiteDescriptor;

import jdk.internal.dynalink.linker.GuardedInvocation;

import jdk.internal.dynalink.linker.LinkRequest;

import jdk.nashorn.internal.codegen.CompilerConstants;

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

import jdk.nashorn.internal.objects.Global;

import jdk.nashorn.internal.runtime.JSType;

import jdk.nashorn.internal.runtime.PropertyDescriptor;

import jdk.nashorn.internal.runtime.UnwarrantedOptimismException;

/**

 * ArrayData - abstraction for wrapping array elements

 */

public abstract class ArrayData {

    /** Minimum chunk size for underlying arrays */

    protected static final int CHUNK_SIZE = 32;

    /** Mask for getting a chunk */

    protected static final int CHUNK_MASK = CHUNK_SIZE - 1;

    /**

     * Immutable empty array to get ScriptObjects started.

     */

    public static final ArrayData EMPTY_ARRAY = new NoTypeArrayData();

    /**

     * Length of the array data. Not necessarily length of the wrapped array.

     */

    protected long length;

    /**

     * Method handle to throw an {@link UnwarrantedOptimismException} when getting an element

     * of the wrong type

     */

    protected static final CompilerConstants.Call THROW_UNWARRANTED = staticCall(MethodHandles.lookup(), ArrayData.class, "throwUnwarranted", void.class, ArrayData.class, int.class, int.class);

    /**

     * Constructor

     * @param length Virtual length of the array.

     */

    protected ArrayData(final long length) {

        this.length = length;

    }

    /**

     * Factory method for unspecified array - start as int

     * @return ArrayData

     */

    public static ArrayData initialArray() {

        return new IntArrayData();

    }

    /**

     * Unwarranted thrower

     *

     * @param data         array data

     * @param programPoint program point

     * @param index        array index

     */

    protected static void throwUnwarranted(final ArrayData data, final int programPoint, final int index) {

        throw new UnwarrantedOptimismException(data.getObject(index), programPoint);

    }

    private static int alignUp(final int size) {

        return size + CHUNK_SIZE - 1 & ~(CHUNK_SIZE - 1);

    }

    /**

     * Generic invalidation hook for script object to have call sites to this array indexing

     * relinked, e.g. when a native array is marked as non extensible

     */

    public void invalidateGetters() {

        //subclass responsibility

    }

    /**

     * Generic invalidation hook for script object to have call sites to this array indexing

     * relinked, e.g. when a native array is marked as non extensible

     */

    public void invalidateSetters() {

        //subclass responsibility

    }

    /**

     * Factory method for unspecified array with given length - start as int array data

     *

     * @param length the initial length

     * @return ArrayData

     */

    public static ArrayData allocate(final int length) {

        if (length == 0) {

            return new IntArrayData();

        } else if (length >= SparseArrayData.MAX_DENSE_LENGTH) {

            return new SparseArrayData(EMPTY_ARRAY, length);

        } else {

            return new DeletedRangeArrayFilter(new IntArrayData(length), 0, length - 1);

        }

    }

    /**

     * Factory method for unspecified given an array object

     *

     * @param  array the array

     * @return ArrayData wrapping this array

     */

    public static ArrayData allocate(final Object array) {

        final Class<?> clazz = array.getClass();

        if (clazz == int[].class) {

            return new IntArrayData((int[])array, ((int[])array).length);

        } else if (clazz == long[].class) {

            return new LongArrayData((long[])array, ((long[])array).length);

        } else if (clazz == double[].class) {

            return new NumberArrayData((double[])array, ((double[])array).length);

        } else {

            return new ObjectArrayData((Object[])array, ((Object[])array).length);

        }

    }

    /**

     * Allocate an ArrayData wrapping a given array

     *

     * @param array the array to use for initial elements

     * @return the ArrayData

     */

    public static ArrayData allocate(final int[] array) {

         return new IntArrayData(array, array.length);

    }

    /**

     * Allocate an ArrayData wrapping a given array

     *

     * @param array the array to use for initial elements

     * @return the ArrayData

     */

    public static ArrayData allocate(final long[] array) {

        return new LongArrayData(array, array.length);

    }

    /**

     * Allocate an ArrayData wrapping a given array

     *

     * @param array the array to use for initial elements

     * @return the ArrayData

     */

    public static ArrayData allocate(final double[] array) {

        return new NumberArrayData(array, array.length);

    }

    /**

     * Allocate an ArrayData wrapping a given array

     *

     * @param array the array to use for initial elements

     * @return the ArrayData

     */

    public static ArrayData allocate(final Object[] array) {

        return new ObjectArrayData(array, array.length);

    }

    /**

     * Allocate an ArrayData wrapping a given nio ByteBuffer

     *

     * @param buf the nio ByteBuffer to wrap

     * @return the ArrayData

     */

    public static ArrayData allocate(final ByteBuffer buf) {

        return new ByteBufferArrayData(buf);

    }

    /**

     * Apply a freeze filter to an ArrayData.

     *

     * @param underlying  the underlying ArrayData to wrap in the freeze filter

     * @return the frozen ArrayData

     */

    public static ArrayData freeze(final ArrayData underlying) {

        return new FrozenArrayFilter(underlying);

    }

    /**

     * Apply a seal filter to an ArrayData.

     *

     * @param underlying  the underlying ArrayData to wrap in the seal filter

     * @return the sealed ArrayData

     */

    public static ArrayData seal(final ArrayData underlying) {

        return new SealedArrayFilter(underlying);

    }

    /**

     * Return the length of the array data. This may differ from the actual

     * length of the array this wraps as length may be set or gotten as any

     * other JavaScript Property

     *

     * Even though a JavaScript array length may be a long, we only store

     * int parts for the optimized array access. For long lengths there

     * are special cases anyway.

     *

     * TODO: represent arrays with "long" lengths as a special ArrayData

     * that basically maps to the ScriptObject directly for better abstraction

     *

     * @return the length of the data

     */

    public final long length() {

        return length;

    }

    /**

     * Return a copy of the array that can be modified without affecting this instance.

     * It is safe to return themselves for immutable subclasses.

     *

     * @return a new array

     */

    public abstract ArrayData copy();

    /**

     * Return a copy of the array data as an Object array.

     *

     * @return an Object array

     */

    public abstract Object[] asObjectArray();

    /**

     * Return a copy of the array data as an array of the specified type.

     *

     * @param componentType  the type of elements in the array

     * @return and array of the given type

     */

    public Object asArrayOfType(final Class<?> componentType) {

        return JSType.convertArray(asObjectArray(), componentType);

    }

    /**

     * Set the length of the data array

     *

     * @param length the new length for the data array

     */

    public void setLength(final long length) {

        this.length = length;

    }

    /**

     * Shift the array data left

     *

     * TODO: explore start at an index and not at zero, to make these operations

     * even faster. Offset everything from the index. Costs memory but is probably

     * worth it

     *

     * @param by offset to shift

     */

    public abstract void shiftLeft(int by);

    /**

     * Shift the array right

     *

     * @param by offset to shift

     * @return New arraydata (or same)

     */

    public abstract ArrayData shiftRight(int by);

    /**

     * Ensure that the given index exists and won't fail subsequent

     *

     * @param safeIndex the index to ensure wont go out of bounds

     * @return new array data (or same)

     */

    public abstract ArrayData ensure(long safeIndex);

    /**

     * Shrink the array to a new length, may or may not retain the

     * inner array

     *

     * @param newLength new max length

     *

     * @return new array data (or same)

     */

    public abstract ArrayData shrink(long newLength);

    /**

     * Set an object value at a given index

     *

     * @param index the index

     * @param value the value

     * @param strict are we in strict mode

     * @return new array data (or same)

     */

    public abstract ArrayData set(int index, Object value, boolean strict);

    /**

     * Set an int value at a given index

     *

     * @param index the index

     * @param value the value

     * @param strict are we in strict mode

     * @return new array data (or same)

     */

    public abstract ArrayData set(int index, int value, boolean strict);

    /**

     * Set a long value at a given index

     *

     * @param index the index

     * @param value the value

     * @param strict are we in strict mode

     * @return new array data (or same)

     */

    public abstract ArrayData set(int index, long value, boolean strict);

    /**

     * Set an double value at a given index

     *

     * @param index the index

     * @param value the value

     * @param strict are we in strict mode

     * @return new array data (or same)

     */

    public abstract ArrayData set(int index, double value, boolean strict);

    /**

     * Set an empty value at a given index. Should only affect Object array.

     *

     * @param index the index

     * @return new array data (or same)

     */

    public ArrayData setEmpty(final int index) {

        // Do nothing.

        return this;

    }

    /**

     * Set an empty value for a given range. Should only affect Object array.

     *

     * @param lo range low end

     * @param hi range high end

     * @return new array data (or same)

     */

    public ArrayData setEmpty(final long lo, final long hi) {

        // Do nothing.

        return this;

    }

    /**

     * Get an int value from a given index

     *

     * @param index the index

     * @return the value

     */

    public abstract int getInt(int index);

    /**

     * Returns the optimistic type of this array data. Basically, when an array data object needs to throw an

     * {@link UnwarrantedOptimismException}, this type is used as the actual type of the return value.

     * @return the optimistic type of this array data.

     */

    public Type getOptimisticType() {

        return Type.OBJECT;

    }

    /**

     * Get optimistic int - default is that it's impossible. Overridden

     * by arrays that actually represents ints

     *

     * @param index        the index

     * @param programPoint program point

     * @return the value

     */

    public int getIntOptimistic(final int index, final int programPoint) {

        throw new UnwarrantedOptimismException(getObject(index), programPoint, getOptimisticType());

    }

    /**

     * Get a long value from a given index

     *

     * @param index the index

     * @return the value

     */

    public abstract long getLong(int index);

    /**

     * Get optimistic long - default is that it's impossible. Overridden

     * by arrays that actually represents longs or narrower

     *

     * @param index        the index

     * @param programPoint program point

     * @return the value

     */

    public long getLongOptimistic(final int index, final int programPoint) {

        throw new UnwarrantedOptimismException(getObject(index), programPoint, getOptimisticType());

    }

    /**

     * Get a double value from a given index

     *

     * @param index the index

     * @return the value

     */

    public abstract double getDouble(int index);

    /**

     * Get optimistic double - default is that it's impossible. Overridden

     * by arrays that actually represents doubles or narrower

     *

     * @param index        the index

     * @param programPoint program point

     * @return the value

     */

    public double getDoubleOptimistic(final int index, final int programPoint) {

        throw new UnwarrantedOptimismException(getObject(index), programPoint, getOptimisticType());

    }

    /**

     * Get an Object value from a given index

     *

     * @param index the index

     * @return the value

     */

    public abstract Object getObject(int index);

    /**

     * Tests to see if an entry exists (avoids boxing.)

     * @param index the index

     * @return true if entry exists

     */

    public abstract boolean has(int index);

    /**

     * Returns if element at specific index can be deleted or not.

     *

     * @param index the index of the element

     * @param strict are we in strict mode

     *

     * @return true if element can be deleted

     */

    public boolean canDelete(final int index, final boolean strict) {

        return true;

    }

    /**

     * Returns if element at specific index range can be deleted or not.

     *

     * @param fromIndex  the start index

     * @param toIndex    the end index

     * @param strict     are we in strict mode

     *

     * @return true if range can be deleted

     */

    public boolean canDelete(final long fromIndex, final long toIndex, final boolean strict) {

        return true;

    }

    /**

     * Returns property descriptor for element at a given index

     *

     * @param global the global object

     * @param index  the index

     *

     * @return property descriptor for element

     */

    public PropertyDescriptor getDescriptor(final Global global, final int index) {

        return global.newDataDescriptor(getObject(index), true, true, true);

    }

    /**

     * Delete an array value at the given index, substituting

     * for an undefined

     *

     * @param index the index

     * @return new array data (or same)

     */

    public abstract ArrayData delete(int index);

    /**

     * Delete a given range from this array;

     *

     * @param fromIndex  from index (inclusive)

     * @param toIndex    to index (inclusive)

     *

     * @return new ArrayData after deletion

     */

    public abstract ArrayData delete(long fromIndex, long toIndex);

    /**

     * Convert the ArrayData to one with a different element type