/*

 * 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.lookup.Lookup.MH;

import static jdk.nashorn.internal.runtime.JSType.getAccessorTypeIndex;

import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.isValid;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import jdk.dynalink.CallSiteDescriptor;

import jdk.dynalink.linker.GuardedInvocation;

import jdk.dynalink.linker.support.TypeUtilities;

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

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

/**

 * Optimistic return value filters

 */

public final class OptimisticReturnFilters {

    private static final MethodHandle[] ENSURE_INT;

    private static final MethodHandle[] ENSURE_NUMBER;

    // These extend the type index constants in JSType

    private static final int VOID_TYPE_INDEX;

    private static final int BOOLEAN_TYPE_INDEX;

    private static final int CHAR_TYPE_INDEX;

    private static final int LONG_TYPE_INDEX;

    private static final int FLOAT_TYPE_INDEX;

    static {

        final MethodHandle INT_DOUBLE = findOwnMH("ensureInt", int.class, double.class, int.class);

        ENSURE_INT = new MethodHandle[] {

                null,

                INT_DOUBLE,

                findOwnMH("ensureInt", int.class, Object.class, int.class),

                findOwnMH("ensureInt", int.class, int.class),

                findOwnMH("ensureInt", int.class, boolean.class, int.class),

                findOwnMH("ensureInt", int.class, char.class, int.class),

                findOwnMH("ensureInt", int.class, long.class, int.class),

                INT_DOUBLE.asType(INT_DOUBLE.type().changeParameterType(0, float.class)),

        };

        VOID_TYPE_INDEX = ENSURE_INT.length - 5;

        BOOLEAN_TYPE_INDEX = ENSURE_INT.length - 4;

        CHAR_TYPE_INDEX = ENSURE_INT.length - 3;

        LONG_TYPE_INDEX = ENSURE_INT.length - 2;

        FLOAT_TYPE_INDEX = ENSURE_INT.length - 1;

        ENSURE_NUMBER = new MethodHandle[] {

                null,

                null,

                findOwnMH("ensureNumber", double.class, Object.class, int.class),

                ENSURE_INT[VOID_TYPE_INDEX].asType(ENSURE_INT[VOID_TYPE_INDEX].type().changeReturnType(double.class)),

                ENSURE_INT[BOOLEAN_TYPE_INDEX].asType(ENSURE_INT[BOOLEAN_TYPE_INDEX].type().changeReturnType(double.class)),

                ENSURE_INT[CHAR_TYPE_INDEX].asType(ENSURE_INT[CHAR_TYPE_INDEX].type().changeReturnType(double.class)),

                findOwnMH("ensureNumber", double.class, long.class, int.class),

                null

        };

    }

    /**

     * Given a method handle and an expected return type, perform return value filtering

     * according to the optimistic type coercion rules

     * @param mh method handle

     * @param expectedReturnType expected return type

     * @param programPoint program point

     * @return filtered method

     */

    public static MethodHandle filterOptimisticReturnValue(final MethodHandle mh, final Class<?> expectedReturnType, final int programPoint) {

        if(!isValid(programPoint)) {

            return mh;

        }

        final MethodType type = mh.type();

        final Class<?> actualReturnType = type.returnType();

        if(TypeUtilities.isConvertibleWithoutLoss(actualReturnType, expectedReturnType)) {

            return mh;

        }

        final MethodHandle guard = getOptimisticTypeGuard(expectedReturnType, actualReturnType);

        return guard == null ? mh : MH.filterReturnValue(mh, MH.insertArguments(guard, guard.type().parameterCount() - 1, programPoint));

    }

    /**

     * Given a guarded invocation and a callsite descriptor, perform return value filtering

     * according to the optimistic type coercion rules, using the return value from the descriptor

     * @param inv the invocation

     * @param desc the descriptor

     * @return filtered invocation

     */

    public static GuardedInvocation filterOptimisticReturnValue(final GuardedInvocation inv, final CallSiteDescriptor desc) {

        if(!NashornCallSiteDescriptor.isOptimistic(desc)) {

            return inv;

        }

        return inv.replaceMethods(filterOptimisticReturnValue(inv.getInvocation(), desc.getMethodType().returnType(),

                NashornCallSiteDescriptor.getProgramPoint(desc)), inv.getGuard());

    }

    private static MethodHandle getOptimisticTypeGuard(final Class<?> actual, final Class<?> provable) {

        final MethodHandle guard;

        final int provableTypeIndex = getProvableTypeIndex(provable);

        if (actual == int.class) {

            guard = ENSURE_INT[provableTypeIndex];

        } else if (actual == double.class) {

            guard = ENSURE_NUMBER[provableTypeIndex];

        } else {

            guard = null;

            assert !actual.isPrimitive() : actual + ", " + provable;

        }

        if(guard != null && !(provable.isPrimitive())) {

            // Make sure filtering a MethodHandle(...)String works with a filter MethodHandle(Object, int)... Note that

            // if the return type of the method is incompatible with Number, then the guard will always throw an

            // UnwarrantedOperationException when invoked, but we must link it anyway as we need the guarded function to

            // successfully execute and return the non-convertible return value that it'll put into the thrown

            // UnwarrantedOptimismException.

            return guard.asType(guard.type().changeParameterType(0, provable));

        }

        return guard;

    }

    private static int getProvableTypeIndex(final Class<?> provable) {

        final int accTypeIndex = getAccessorTypeIndex(provable);

        if(accTypeIndex != -1) {

            return accTypeIndex;

        } else if(provable == boolean.class) {

            return BOOLEAN_TYPE_INDEX;

        } else if(provable == void.class) {

            return VOID_TYPE_INDEX;

        } else if(provable == byte.class || provable == short.class) {

            return 0; // never needs a guard, as it's assignable to int

        } else if(provable == char.class) {

            return CHAR_TYPE_INDEX;

        } else if(provable == long.class) {

            return LONG_TYPE_INDEX;

        } else if(provable == float.class) {

            return FLOAT_TYPE_INDEX;

        }

        throw new AssertionError(provable.getName());

    }

    //maps staticallyProvableCallSiteType to actualCallSiteType, throws exception if impossible

    @SuppressWarnings("unused")

    private static int ensureInt(final long arg, final int programPoint) {

        if (JSType.isRepresentableAsInt(arg)) {

            return (int)arg;

        }

        throw UnwarrantedOptimismException.createNarrowest(arg, programPoint);

    }

    @SuppressWarnings("unused")

    private static int ensureInt(final double arg, final int programPoint) {

        if (JSType.isStrictlyRepresentableAsInt(arg)) {

            return (int)arg;

        }

        throw new UnwarrantedOptimismException(arg, programPoint, Type.NUMBER);

    }

    /**

     * Returns the argument value as an int. If the argument is not a wrapper for a primitive numeric type

     * with a value that can be exactly represented as an int, throw an {@link UnwarrantedOptimismException}.

     * This method is only public so that generated script code can use it. See {code CodeGenerator.ENSURE_INT}.

     * @param arg the original argument.

     * @param programPoint the program point used in the exception

     * @return the value of the argument as an int.

     * @throws UnwarrantedOptimismException if the argument is not a wrapper for a primitive numeric type with

     * a value that can be exactly represented as an int.

     */

    public static int ensureInt(final Object arg, final int programPoint) {

        // NOTE: this doesn't delegate to ensureInt(double, int) as in that case if arg were a Long, it would throw a

        // (potentially imprecise) Double in the UnwarrantedOptimismException. This way, it will put the correct valued

        // Long into the exception.

        if (isPrimitiveNumberWrapper(arg)) {

            final double d = ((Number)arg).doubleValue();

            if (JSType.isStrictlyRepresentableAsInt(d)) {

                return (int)d;

            }

        }

        throw UnwarrantedOptimismException.createNarrowest(arg, programPoint);

    }

    private static boolean isPrimitiveNumberWrapper(final Object obj) {

        if (obj == null) {

            return false;

        }

        final Class<?> c = obj.getClass();

        return c == Integer.class || c == Double.class || c == Long.class ||

               c ==   Float.class || c ==  Short.class || c == Byte.class;

    }

    @SuppressWarnings("unused")

    private static int ensureInt(final boolean arg, final int programPoint) {

        throw new UnwarrantedOptimismException(arg, programPoint, Type.OBJECT);

    }

    @SuppressWarnings("unused")

    private static int ensureInt(final char arg, final int programPoint) {

        throw new UnwarrantedOptimismException(arg, programPoint, Type.OBJECT);

    }

    @SuppressWarnings("unused")

    private static int ensureInt(final int programPoint) {

        // Turns a void into UNDEFINED

        throw new UnwarrantedOptimismException(ScriptRuntime.UNDEFINED, programPoint, Type.OBJECT);

    }

    @SuppressWarnings("unused")

    private static double ensureNumber(final long arg, final int programPoint) {

        if (JSType.isRepresentableAsDouble(arg)) {

            return (double) arg;

        }

        throw new UnwarrantedOptimismException(arg, programPoint, Type.OBJECT);

    }

    /**

     * Returns the argument value as a double. If the argument is not a wrapper for a primitive numeric type

     * that can be represented as double throw an {@link UnwarrantedOptimismException}.

     * This method is only public so that generated script code can use it. See {code CodeGenerator.ENSURE_NUMBER}.

     * @param arg the original argument.

     * @param programPoint the program point used in the exception

     * @return the value of the argument as a double.

     * @throws UnwarrantedOptimismException if the argument is not a wrapper for a primitive numeric type.

     */

    public static double ensureNumber(final Object arg, final int programPoint) {

        if (isPrimitiveNumberWrapper(arg)

                && (arg.getClass() != Long.class || JSType.isRepresentableAsDouble((Long) arg))) {

            return ((Number) arg).doubleValue();

        }

        throw new UnwarrantedOptimismException(arg, programPoint, Type.OBJECT);

    }

    private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {

        return MH.findStatic(MethodHandles.lookup(), OptimisticReturnFilters.class, name, MH.type(rtype, types));

    }

}