/*

 * 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.CompilerConstants.staticCall;

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

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

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.reflect.Array;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import jdk.dynalink.SecureLookupSupplier;

import jdk.dynalink.beans.StaticClass;

import jdk.nashorn.api.scripting.JSObject;

import jdk.nashorn.internal.codegen.CompilerConstants.Call;

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

import jdk.nashorn.internal.objects.Global;

import jdk.nashorn.internal.objects.NativeSymbol;

import jdk.nashorn.internal.parser.Lexer;

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

import jdk.nashorn.internal.runtime.doubleconv.DoubleConversion;

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

/**

 * Representation for ECMAScript types - this maps directly to the ECMA script standard

 */

public enum JSType {

    /** The undefined type */

    UNDEFINED("undefined"),

    /** The null type */

    NULL("object"),

    /** The boolean type */

    BOOLEAN("boolean"),

    /** The number type */

    NUMBER("number"),

    /** The string type */

    STRING("string"),

    /** The object type */

    OBJECT("object"),

    /** The function type */

    FUNCTION("function"),

    /** The symbol type */

    SYMBOL("symbol");

    /** The type name as returned by ECMAScript "typeof" operator*/

    private final String typeName;

    /** Max value for an uint32 in JavaScript */

    public static final long MAX_UINT = 0xFFFF_FFFFL;

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

    /** JavaScript compliant conversion function from Object to boolean */

    public static final Call TO_BOOLEAN = staticCall(JSTYPE_LOOKUP, JSType.class, "toBoolean", boolean.class, Object.class);

    /** JavaScript compliant conversion function from number to boolean */

    public static final Call TO_BOOLEAN_D = staticCall(JSTYPE_LOOKUP, JSType.class, "toBoolean", boolean.class, double.class);

    /** JavaScript compliant conversion function from Object to integer */

    public static final Call TO_INTEGER = staticCall(JSTYPE_LOOKUP, JSType.class, "toInteger", int.class, Object.class);

    /** JavaScript compliant conversion function from Object to long */

    public static final Call TO_LONG = staticCall(JSTYPE_LOOKUP, JSType.class, "toLong", long.class, Object.class);

    /** JavaScript compliant conversion function from double to long */

    public static final Call TO_LONG_D = staticCall(JSTYPE_LOOKUP, JSType.class, "toLong", long.class, double.class);

    /** JavaScript compliant conversion function from Object to number */

    public static final Call TO_NUMBER = staticCall(JSTYPE_LOOKUP, JSType.class, "toNumber", double.class, Object.class);

    /** JavaScript compliant conversion function from Object to number with type check */

    public static final Call TO_NUMBER_OPTIMISTIC = staticCall(JSTYPE_LOOKUP, JSType.class, "toNumberOptimistic", double.class, Object.class, int.class);

    /** JavaScript compliant conversion function from Object to String */

    public static final Call TO_STRING = staticCall(JSTYPE_LOOKUP, JSType.class, "toString", String.class, Object.class);

    /** JavaScript compliant conversion function from Object to int32 */

    public static final Call TO_INT32 = staticCall(JSTYPE_LOOKUP, JSType.class, "toInt32", int.class, Object.class);

    /** JavaScript compliant conversion function from Object to int32 */

    public static final Call TO_INT32_L = staticCall(JSTYPE_LOOKUP, JSType.class, "toInt32", int.class, long.class);

    /** JavaScript compliant conversion function from Object to int32 with type check */

    public static final Call TO_INT32_OPTIMISTIC = staticCall(JSTYPE_LOOKUP, JSType.class, "toInt32Optimistic", int.class, Object.class, int.class);

    /** JavaScript compliant conversion function from double to int32 */

    public static final Call TO_INT32_D = staticCall(JSTYPE_LOOKUP, JSType.class, "toInt32", int.class, double.class);

    /** JavaScript compliant conversion function from int to uint32 */

    public static final Call TO_UINT32_OPTIMISTIC = staticCall(JSTYPE_LOOKUP, JSType.class, "toUint32Optimistic", int.class, int.class, int.class);

    /** JavaScript compliant conversion function from int to uint32 */

    public static final Call TO_UINT32_DOUBLE = staticCall(JSTYPE_LOOKUP, JSType.class, "toUint32Double", double.class, int.class);

    /** JavaScript compliant conversion function from Object to uint32 */

    public static final Call TO_UINT32 = staticCall(JSTYPE_LOOKUP, JSType.class, "toUint32", long.class, Object.class);

    /** JavaScript compliant conversion function from number to uint32 */

    public static final Call TO_UINT32_D = staticCall(JSTYPE_LOOKUP, JSType.class, "toUint32", long.class, double.class);

    /** JavaScript compliant conversion function from number to String */

    public static final Call TO_STRING_D = staticCall(JSTYPE_LOOKUP, JSType.class, "toString", String.class, double.class);

    /** Combined call to toPrimitive followed by toString. */

    public static final Call TO_PRIMITIVE_TO_STRING = staticCall(JSTYPE_LOOKUP, JSType.class, "toPrimitiveToString", String.class, Object.class);

    /** Combined call to toPrimitive followed by toCharSequence. */

    public static final Call TO_PRIMITIVE_TO_CHARSEQUENCE = staticCall(JSTYPE_LOOKUP, JSType.class, "toPrimitiveToCharSequence", CharSequence.class, Object.class);

    /** Throw an unwarranted optimism exception */

    public static final Call THROW_UNWARRANTED = staticCall(JSTYPE_LOOKUP, JSType.class, "throwUnwarrantedOptimismException", Object.class, Object.class, int.class);

    /** Add exact wrapper for potentially overflowing integer operations */

    public static final Call ADD_EXACT       = staticCall(JSTYPE_LOOKUP, JSType.class, "addExact", int.class, int.class, int.class, int.class);

    /** Sub exact wrapper for potentially overflowing integer operations */

    public static final Call SUB_EXACT       = staticCall(JSTYPE_LOOKUP, JSType.class, "subExact", int.class, int.class, int.class, int.class);

    /** Multiply exact wrapper for potentially overflowing integer operations */

    public static final Call MUL_EXACT       = staticCall(JSTYPE_LOOKUP, JSType.class, "mulExact", int.class, int.class, int.class, int.class);

    /** Div exact wrapper for potentially integer division that turns into float point */

    public static final Call DIV_EXACT       = staticCall(JSTYPE_LOOKUP, JSType.class, "divExact", int.class, int.class, int.class, int.class);

    /** Div zero wrapper for integer division that handles (0/0)|0 == 0 */

    public static final Call DIV_ZERO        = staticCall(JSTYPE_LOOKUP, JSType.class, "divZero", int.class, int.class, int.class);

    /** Mod zero wrapper for integer division that handles (0%0)|0 == 0 */

    public static final Call REM_ZERO        = staticCall(JSTYPE_LOOKUP, JSType.class, "remZero", int.class, int.class, int.class);

    /** Mod exact wrapper for potentially integer remainders that turns into float point */

    public static final Call REM_EXACT       = staticCall(JSTYPE_LOOKUP, JSType.class, "remExact", int.class, int.class, int.class, int.class);

    /** Decrement exact wrapper for potentially overflowing integer operations */

    public static final Call DECREMENT_EXACT = staticCall(JSTYPE_LOOKUP, JSType.class, "decrementExact",   int.class, int.class, int.class);

    /** Increment exact wrapper for potentially overflowing integer operations */

    public static final Call INCREMENT_EXACT = staticCall(JSTYPE_LOOKUP, JSType.class, "incrementExact",   int.class, int.class, int.class);

    /** Negate exact exact wrapper for potentially overflowing integer operations */

    public static final Call NEGATE_EXACT         = staticCall(JSTYPE_LOOKUP, JSType.class, "negateExact", int.class, int.class, int.class);

    /** Method handle to convert a JS Object to a Java array. */

    public static final Call TO_JAVA_ARRAY = staticCall(JSTYPE_LOOKUP, JSType.class, "toJavaArray", Object.class, Object.class, Class.class);

    /** Method handle to convert a JS Object to a Java array. */

    public static final Call TO_JAVA_ARRAY_WITH_LOOKUP = staticCall(JSTYPE_LOOKUP, JSType.class, "toJavaArrayWithLookup", Object.class, Object.class, Class.class, SecureLookupSupplier.class);

    /** Method handle for void returns. */

    public static final Call VOID_RETURN = staticCall(JSTYPE_LOOKUP, JSType.class, "voidReturn", void.class);

    /** Method handle for isString method */

    public static final Call IS_STRING = staticCall(JSTYPE_LOOKUP, JSType.class, "isString", boolean.class, Object.class);

    /** Method handle for isNumber method */

    public static final Call IS_NUMBER = staticCall(JSTYPE_LOOKUP, JSType.class, "isNumber", boolean.class, Object.class);

    /**

     * The list of available accessor types in width order. This order is used for type guesses narrow{@literal ->} wide

     *  in the dual--fields world

     */

    private static final List<Type> ACCESSOR_TYPES = Collections.unmodifiableList(

            Arrays.asList(

                Type.INT,

                Type.NUMBER,

                Type.OBJECT));

    /** table index for undefined type - hard coded so it can be used in switches at compile time */

    public static final int TYPE_UNDEFINED_INDEX = -1;

    /** table index for integer type - hard coded so it can be used in switches at compile time */

    public static final int TYPE_INT_INDEX    = 0; //getAccessorTypeIndex(int.class);

    /** table index for double type - hard coded so it can be used in switches at compile time */

    public static final int TYPE_DOUBLE_INDEX = 1; //getAccessorTypeIndex(double.class);

    /** table index for object type - hard coded so it can be used in switches at compile time */

    public static final int TYPE_OBJECT_INDEX = 2; //getAccessorTypeIndex(Object.class);

    /** object conversion quickies with JS semantics - used for return value and parameter filter */

    public static final List<MethodHandle> CONVERT_OBJECT = toUnmodifiableList(

        JSType.TO_INT32.methodHandle(),

        JSType.TO_NUMBER.methodHandle(),

        null

    );

    /**

     * object conversion quickies with JS semantics - used for return value and parameter filter, optimistic

     * throws exception upon incompatible type (asking for a narrower one than the storage)

     */

    public static final List<MethodHandle> CONVERT_OBJECT_OPTIMISTIC = toUnmodifiableList(

        JSType.TO_INT32_OPTIMISTIC.methodHandle(),

        JSType.TO_NUMBER_OPTIMISTIC.methodHandle(),

        null

    );

    /** The value of Undefined cast to an int32 */

    public static final int    UNDEFINED_INT    = 0;

    /** The value of Undefined cast to a long */

    public static final long   UNDEFINED_LONG   = 0L;

    /** The value of Undefined cast to a double */

    public static final double UNDEFINED_DOUBLE = Double.NaN;

    // Minimum and maximum range between which every long value can be precisely represented as a double.

    private static final long MAX_PRECISE_DOUBLE = 1L << 53;

    private static final long MIN_PRECISE_DOUBLE = -MAX_PRECISE_DOUBLE;

    /**

     * Method handles for getters that return undefined coerced

     * to the appropriate type

     */

    public static final List<MethodHandle> GET_UNDEFINED = toUnmodifiableList(

        MH.constant(int.class, UNDEFINED_INT),

        MH.constant(double.class, UNDEFINED_DOUBLE),

        MH.constant(Object.class, Undefined.getUndefined())

    );

    private static final double INT32_LIMIT = 4294967296.0;

    /**

     * Constructor

     *

     * @param typeName the type name

     */

    private JSType(final String typeName) {

        this.typeName = typeName;

    }

    /**

     * The external type name as returned by ECMAScript "typeof" operator

     *

     * @return type name for this type

     */

    public final String typeName() {

        return this.typeName;

    }

    /**

     * Return the JSType for a given object

     *

     * @param obj an object

     *

     * @return the JSType for the object

     */

    public static JSType of(final Object obj) {

        // Order of these statements is tuned for performance (see JDK-8024476)

        if (obj == null) {

            return JSType.NULL;

        }

        if (obj instanceof ScriptObject) {

            return obj instanceof ScriptFunction ? JSType.FUNCTION : JSType.OBJECT;

        }

        if (obj instanceof Boolean) {

            return JSType.BOOLEAN;

        }

        if (isString(obj)) {

            return JSType.STRING;

        }

        if (isNumber(obj)) {

            return JSType.NUMBER;

        }

        if (obj instanceof Symbol) {

            return JSType.SYMBOL;

        }

        if (obj == ScriptRuntime.UNDEFINED) {

            return JSType.UNDEFINED;

        }

        return Bootstrap.isCallable(obj) ? JSType.FUNCTION : JSType.OBJECT;

    }

    /**

     * Similar to {@link #of(Object)}, but does not distinguish between {@link #FUNCTION} and {@link #OBJECT}, returning

     * {@link #OBJECT} in both cases. The distinction is costly, and the EQ and STRICT_EQ predicates don't care about it

     * so we maintain this version for their use.

     *

     * @param obj an object

     *

     * @return the JSType for the object; returns {@link #OBJECT} instead of {@link #FUNCTION} for functions.

     */

    public static JSType ofNoFunction(final Object obj) {

        // Order of these statements is tuned for performance (see JDK-8024476)

        if (obj == null) {

            return JSType.NULL;

        }

        if (obj instanceof ScriptObject) {

            return JSType.OBJECT;

        }

        if (obj instanceof Boolean) {

            return JSType.BOOLEAN;

        }

        if (isString(obj)) {

            return JSType.STRING;

        }

        if (isNumber(obj)) {

            return JSType.NUMBER;

        }

        if (obj == ScriptRuntime.UNDEFINED) {

            return JSType.UNDEFINED;

        }

        if (obj instanceof Symbol) {

            return JSType.SYMBOL;

        }

        return JSType.OBJECT;

    }

    /**

     * Void return method handle glue

     */

    public static void voidReturn() {

        //empty

        //TODO: fix up SetMethodCreator better so we don't need this stupid thing

    }

    /**

     * Returns true if double number can be represented as an int

     *

     * @param number a long to inspect

     *

     * @return true for int representable longs

     */

    public static boolean isRepresentableAsInt(final long number) {

        return (int)number == number;

    }

    /**

     * Returns true if double number can be represented as an int. Note that it returns true for negative

     * zero. If you need to exclude negative zero, use {@link #isStrictlyRepresentableAsInt(double)}.

     *

     * @param number a double to inspect

     *

     * @return true for int representable doubles

     */

    public static boolean isRepresentableAsInt(final double number) {

        return (int)number == number;

    }

    /**

     * Returns true if double number can be represented as an int. Note that it returns false for negative

     * zero. If you don't need to distinguish negative zero, use {@link #isRepresentableAsInt(double)}.

     *

     * @param number a double to inspect

     *

     * @return true for int representable doubles

     */

    public static boolean isStrictlyRepresentableAsInt(final double number) {

        return isRepresentableAsInt(number) && isNotNegativeZero(number);

    }

    /**

     * Returns true if Object can be represented as an int

     *

     * @param obj an object to inspect

     *

     * @return true for int representable objects

     */

    public static boolean isRepresentableAsInt(final Object obj) {

        if (obj instanceof Number) {

            return isRepresentableAsInt(((Number)obj).doubleValue());

        }

        return false;

    }

    /**

     * Returns true if double number can be represented as a long. Note that it returns true for negative

     * zero.

     *

     * @param number a double to inspect

     * @return true for long representable doubles

     */

    public static boolean isRepresentableAsLong(final double number) {

        return (long)number == number;

    }

    /**

     * Returns true if long number can be represented as double without loss of precision.

     * @param number a long number

     * @return true if the double representation does not lose precision

     */

    public static boolean isRepresentableAsDouble(final long number) {

        return MAX_PRECISE_DOUBLE >= number && number >= MIN_PRECISE_DOUBLE;

    }

    /**

     * Returns true if the number is not the negative zero ({@code -0.0d}).

     * @param number the number to test

     * @return true if it is not the negative zero, false otherwise.

     */

    private static boolean isNotNegativeZero(final double number) {

        return Double.doubleToRawLongBits(number) != 0x8000000000000000L;

    }

    /**

     * Check whether an object is primitive

     *

     * @param obj an object

     *

     * @return true if object is primitive (includes null and undefined)

     */

    public static boolean isPrimitive(final Object obj) {

        return obj == null ||

               obj == ScriptRuntime.UNDEFINED ||

               isString(obj) ||

               isNumber(obj) ||

               obj instanceof Boolean ||

               obj instanceof Symbol;

    }

   /**

    * Primitive converter for an object

    *

    * @param obj an object

    *

    * @return primitive form of the object

    */

    public static Object toPrimitive(final Object obj) {

        return toPrimitive(obj, null);

    }

    /**

     * Primitive converter for an object including type hint

     * See ECMA 9.1 ToPrimitive

     *

     * @param obj  an object

     * @param hint a type hint

     *

     * @return the primitive form of the object

     */

    public static Object toPrimitive(final Object obj, final Class<?> hint) {

        if (obj instanceof ScriptObject) {

            return toPrimitive((ScriptObject)obj, hint);

        } else if (isPrimitive(obj)) {

            return obj;

        } else if (obj instanceof JSObject) {

            return toPrimitive((JSObject)obj, hint);

        } else if (obj instanceof StaticClass) {

            final String name = ((StaticClass)obj).getRepresentedClass().getName();

            return new StringBuilder(12 + name.length()).append("[JavaClass ").append(name).append(']').toString();

        }

        return obj.toString();

    }

    private static Object toPrimitive(final ScriptObject sobj, final Class<?> hint) {

        return requirePrimitive(sobj.getDefaultValue(hint));

    }

    private static Object requirePrimitive(final Object result) {

        if (!isPrimitive(result)) {

            throw typeError("bad.default.value", result.toString());

        }

        return result;