/**
  * Boostrapper for math calls that may overflow
  *
  * @param lookup lookup
  * @param name name of operation
  * @param type method type
  * @param programPoint program point to bind to callsite
  * @return callsite for a math intrinsic node
  */
 public static CallSite mathBootstrap(
     final Lookup lookup, final String name, final MethodType type, final int programPoint) {
   final MethodHandle mh;
   switch (name) {
     case "iadd":
       mh = JSType.ADD_EXACT.methodHandle();
       break;
     case "isub":
       mh = JSType.SUB_EXACT.methodHandle();
       break;
     case "imul":
       mh = JSType.MUL_EXACT.methodHandle();
       break;
     case "idiv":
       mh = JSType.DIV_EXACT.methodHandle();
       break;
     case "irem":
       mh = JSType.REM_EXACT.methodHandle();
       break;
     case "ineg":
       mh = JSType.NEGATE_EXACT.methodHandle();
       break;
     default:
       throw new AssertionError("unsupported math intrinsic");
   }
   return new ConstantCallSite(
       MH.insertArguments(mh, mh.type().parameterCount() - 1, programPoint));
 }
/** This class houses bootstrap method for invokedynamic instructions generated by compiler. */
public final class Bootstrap {
  /** Reference to the seed boostrap function */
  public static final Call BOOTSTRAP =
      staticCallNoLookup(
          Bootstrap.class,
          "bootstrap",
          CallSite.class,
          Lookup.class,
          String.class,
          MethodType.class,
          int.class);

  private static final MethodHandleFunctionality MH = MethodHandleFactory.getFunctionality();

  private static final MethodHandle VOID_TO_OBJECT =
      MH.constant(Object.class, ScriptRuntime.UNDEFINED);

  /**
   * The default dynalink relink threshold for megamorphism is 8. In the case of object fields only,
   * it is fine. However, with dual fields, in order to get performance on benchmarks with a lot of
   * object instantiation and then field reassignment, it can take slightly more relinks to become
   * stable with type changes swapping out an entire property map and making a map guard fail. Since
   * we need to set this value statically it must work with possibly changing optimistic types and
   * dual fields settings. A higher value does not seem to have any other negative performance
   * implication when running with object-only fields, so we choose a higher value here.
   *
   * <p>See for example octane.gbemu, run with --log=fields:warning to study megamorphic behavior
   */
  private static final int NASHORN_DEFAULT_UNSTABLE_RELINK_THRESHOLD = 16;

  // do not create me!!
  private Bootstrap() {}

  private static final DynamicLinker dynamicLinker;

  static {
    final DynamicLinkerFactory factory = new DynamicLinkerFactory();
    final NashornBeansLinker nashornBeansLinker = new NashornBeansLinker();
    factory.setPrioritizedLinkers(
        new NashornLinker(),
        new NashornPrimitiveLinker(),
        new NashornStaticClassLinker(),
        new BoundCallableLinker(),
        new JavaSuperAdapterLinker(),
        new JSObjectLinker(nashornBeansLinker),
        new BrowserJSObjectLinker(nashornBeansLinker),
        new ReflectionCheckLinker());
    factory.setFallbackLinkers(nashornBeansLinker, new NashornBottomLinker());
    factory.setSyncOnRelink(true);
    factory.setPrelinkFilter(
        new GuardedInvocationFilter() {
          @Override
          public GuardedInvocation filter(
              final GuardedInvocation inv,
              final LinkRequest request,
              final LinkerServices linkerServices) {
            final CallSiteDescriptor desc = request.getCallSiteDescriptor();
            return OptimisticReturnFilters.filterOptimisticReturnValue(inv, desc)
                .asType(linkerServices, desc.getMethodType());
          }
        });
    factory.setAutoConversionStrategy(
        new MethodTypeConversionStrategy() {
          @Override
          public MethodHandle asType(final MethodHandle target, final MethodType newType) {
            return unboxReturnType(target, newType);
          }
        });
    factory.setInternalObjectsFilter(NashornBeansLinker.createHiddenObjectFilter());
    final int relinkThreshold =
        Options.getIntProperty(
            "nashorn.unstable.relink.threshold", NASHORN_DEFAULT_UNSTABLE_RELINK_THRESHOLD);
    if (relinkThreshold > -1) {
      factory.setUnstableRelinkThreshold(relinkThreshold);
    }

    // Linkers for any additional language runtimes deployed alongside Nashorn will be picked up by
    // the factory.
    factory.setClassLoader(Bootstrap.class.getClassLoader());

    dynamicLinker = factory.createLinker();
  }

  /**
   * Returns if the given object is a "callable"
   *
   * @param obj object to be checked for callability
   * @return true if the obj is callable
   */
  public static boolean isCallable(final Object obj) {
    if (obj == ScriptRuntime.UNDEFINED || obj == null) {
      return false;
    }

    return obj instanceof ScriptFunction
        || isJSObjectFunction(obj)
        || BeansLinker.isDynamicMethod(obj)
        || obj instanceof BoundCallable
        || isFunctionalInterfaceObject(obj)
        || obj instanceof StaticClass;
  }

  /**
   * Returns true if the given object is a strict callable
   *
   * @param callable the callable object to be checked for strictness
   * @return true if the obj is a strict callable, false if it is a non-strict callable.
   * @throws ECMAException with {@code TypeError} if the object is not a callable.
   */
  public static boolean isStrictCallable(final Object callable) {
    if (callable instanceof ScriptFunction) {
      return ((ScriptFunction) callable).isStrict();
    } else if (isJSObjectFunction(callable)) {
      return ((JSObject) callable).isStrictFunction();
    } else if (callable instanceof BoundCallable) {
      return isStrictCallable(((BoundCallable) callable).getCallable());
    } else if (BeansLinker.isDynamicMethod(callable)
        || callable instanceof StaticClass
        || isFunctionalInterfaceObject(callable)) {
      return false;
    }
    throw notFunction(callable);
  }

  private static ECMAException notFunction(final Object obj) {
    return typeError("not.a.function", ScriptRuntime.safeToString(obj));
  }

  private static boolean isJSObjectFunction(final Object obj) {
    return obj instanceof JSObject && ((JSObject) obj).isFunction();
  }

  /**
   * Returns if the given object is a dynalink Dynamic method
   *
   * @param obj object to be checked
   * @return true if the obj is a dynamic method
   */
  public static boolean isDynamicMethod(final Object obj) {
    return BeansLinker.isDynamicMethod(
        obj instanceof BoundCallable ? ((BoundCallable) obj).getCallable() : obj);
  }

  /**
   * Returns if the given object is an instance of an interface annotated with
   * java.lang.FunctionalInterface
   *
   * @param obj object to be checked
   * @return true if the obj is an instance of @FunctionalInterface interface
   */
  public static boolean isFunctionalInterfaceObject(final Object obj) {
    return !JSType.isPrimitive(obj)
        && (NashornBeansLinker.getFunctionalInterfaceMethodName(obj.getClass()) != null);
  }

  /**
   * Create a call site and link it for Nashorn. This version of the method conforms to the
   * invokedynamic bootstrap method expected signature and is referenced from Nashorn generated
   * bytecode as the bootstrap method for all invokedynamic instructions.
   *
   * @param lookup MethodHandle lookup. Ignored as Nashorn only uses public lookup.
   * @param opDesc Dynalink dynamic operation descriptor.
   * @param type Method type.
   * @param flags flags for call type, trace/profile etc.
   * @return CallSite with MethodHandle to appropriate method or null if not found.
   */
  public static CallSite bootstrap(
      final Lookup lookup, final String opDesc, final MethodType type, final int flags) {
    return dynamicLinker.link(LinkerCallSite.newLinkerCallSite(lookup, opDesc, type, flags));
  }

  /**
   * Boostrapper for math calls that may overflow
   *
   * @param lookup lookup
   * @param name name of operation
   * @param type method type
   * @param programPoint program point to bind to callsite
   * @return callsite for a math intrinsic node
   */
  public static CallSite mathBootstrap(
      final Lookup lookup, final String name, final MethodType type, final int programPoint) {
    final MethodHandle mh;
    switch (name) {
      case "iadd":
        mh = JSType.ADD_EXACT.methodHandle();
        break;
      case "isub":
        mh = JSType.SUB_EXACT.methodHandle();
        break;
      case "imul":
        mh = JSType.MUL_EXACT.methodHandle();
        break;
      case "idiv":
        mh = JSType.DIV_EXACT.methodHandle();
        break;
      case "irem":
        mh = JSType.REM_EXACT.methodHandle();
        break;
      case "ineg":
        mh = JSType.NEGATE_EXACT.methodHandle();
        break;
      default:
        throw new AssertionError("unsupported math intrinsic");
    }
    return new ConstantCallSite(
        MH.insertArguments(mh, mh.type().parameterCount() - 1, programPoint));
  }

  /**
   * Returns a dynamic invoker for a specified dynamic operation using the public lookup. You can
   * use this method to create a method handle that when invoked acts completely as if it were a
   * Nashorn-linked call site. An overview of available dynamic operations can be found in the <a
   * href="https://github.com/szegedi/dynalink/wiki/User-Guide-0.6">Dynalink User Guide</a>, but
   * we'll show few examples here:
   *
   * <ul>
   *   <li>Get a named property with fixed name:
   *       <pre>
   * MethodHandle getColor = Boostrap.createDynamicInvoker("dyn:getProp:color", Object.class, Object.class);
   * Object obj = ...; // somehow obtain the object
   * Object color = getColor.invokeExact(obj);
   *     </pre>
   *   <li>Get a named property with variable name:
   *       <pre>
   * MethodHandle getProperty = Boostrap.createDynamicInvoker("dyn:getElem", Object.class, Object.class, String.class);
   * Object obj = ...; // somehow obtain the object
   * Object color = getProperty.invokeExact(obj, "color");
   * Object shape = getProperty.invokeExact(obj, "shape");
   * MethodHandle getNumProperty = Boostrap.createDynamicInvoker("dyn:getElem", Object.class, Object.class, int.class);
   * Object elem42 = getNumProperty.invokeExact(obj, 42);
   *     </pre>
   *   <li>Set a named property with fixed name:
   *       <pre>
   * MethodHandle setColor = Boostrap.createDynamicInvoker("dyn:setProp:color", void.class, Object.class, Object.class);
   * Object obj = ...; // somehow obtain the object
   * setColor.invokeExact(obj, Color.BLUE);
   *     </pre>
   *   <li>Set a property with variable name:
   *       <pre>
   * MethodHandle setProperty = Boostrap.createDynamicInvoker("dyn:setElem", void.class, Object.class, String.class, Object.class);
   * Object obj = ...; // somehow obtain the object
   * setProperty.invokeExact(obj, "color", Color.BLUE);
   * setProperty.invokeExact(obj, "shape", Shape.CIRCLE);
   *     </pre>
   *   <li>Call a function on an object; two-step variant. This is the actual variant used by
   *       Nashorn-generated code:
   *       <pre>
   * MethodHandle findFooFunction = Boostrap.createDynamicInvoker("dyn:getMethod:foo", Object.class, Object.class);
   * Object obj = ...; // somehow obtain the object
   * Object foo_fn = findFooFunction.invokeExact(obj);
   * MethodHandle callFunctionWithTwoArgs = Boostrap.createDynamicInvoker("dyn:call", Object.class, Object.class, Object.class, Object.class, Object.class);
   * // Note: "call" operation takes a function, then a "this" value, then the arguments:
   * Object foo_retval = callFunctionWithTwoArgs.invokeExact(foo_fn, obj, arg1, arg2);
   *     </pre>
   *   <li>Call a function on an object; single-step variant. Although Nashorn doesn't use this
   *       variant and never emits any INVOKEDYNAMIC instructions with {@code dyn:getMethod}, it
   *       still supports this standard Dynalink operation:
   *       <pre>
   * MethodHandle callFunctionFooWithTwoArgs = Boostrap.createDynamicInvoker("dyn:callMethod:foo", Object.class, Object.class, Object.class, Object.class);
   * Object obj = ...; // somehow obtain the object
   * Object foo_retval = callFunctionFooWithTwoArgs.invokeExact(obj, arg1, arg2);
   *     </pre>
   * </ul>
   *
   * Few additional remarks:
   *
   * <ul>
   *   <li>Just as Nashorn works with any Java object, the invokers returned from this method can
   *       also be applied to arbitrary Java objects in addition to Nashorn JavaScript objects.
   *   <li>For invoking a named function on an object, you can also use the {@link InvokeByName}
   *       convenience class.
   *   <li>For Nashorn objects {@code getElem}, {@code getProp}, and {@code getMethod} are handled
   *       almost identically, since JavaScript doesn't distinguish between different kinds of
   *       properties on an object. Either can be used with fixed property name or a variable
   *       property name. The only significant difference is handling of missing properties: {@code
   *       getMethod} for a missing member will link to a potential invocation of {@code
   *       __noSuchMethod__} on the object, {@code getProp} for a missing member will link to a
   *       potential invocation of {@code __noSuchProperty__}, while {@code getElem} for a missing
   *       member will link to an empty getter.
   *   <li>In similar vein, {@code setElem} and {@code setProp} are handled identically on Nashorn
   *       objects.
   *   <li>There's no rule that the variable property identifier has to be a {@code String} for
   *       {@code getProp/setProp} and {@code int} for {@code getElem/setElem}. You can declare
   *       their type to be {@code int}, {@code double}, {@code Object}, and so on regardless of the
   *       kind of the operation.
   *   <li>You can be as specific in parameter types as you want. E.g. if you know that the receiver
   *       of the operation will always be {@code ScriptObject}, you can pass {@code
   *       ScriptObject.class} as its parameter type. If you happen to link to a method that expects
   *       different types, (you can use these invokers on POJOs too, after all, and end up linking
   *       with their methods that have strongly-typed signatures), all necessary conversions
   *       allowed by either Java or JavaScript will be applied: if invoked methods specify either
   *       primitive or wrapped Java numeric types, or {@code String} or {@code boolean/Boolean},
   *       then the parameters might be subjected to standard ECMAScript {@code ToNumber}, {@code
   *       ToString}, and {@code ToBoolean} conversion, respectively. Less obviously, if the
   *       expected parameter type is a SAM type, and you pass a JavaScript function, a proxy object
   *       implementing the SAM type and delegating to the function will be passed. Linkage can
   *       often be optimized when linkers have more specific type information than "everything can
   *       be an object".
   *   <li>You can also be as specific in return types as you want. For return types any necessary
   *       type conversion available in either Java or JavaScript will be automatically applied,
   *       similar to the process described for parameters, only in reverse direction: if you
   *       specify any either primitive or wrapped Java numeric type, or {@code String} or {@code
   *       boolean/Boolean}, then the return values will be subjected to standard ECMAScript {@code
   *       ToNumber}, {@code ToString}, and {@code ToBoolean} conversion, respectively. Less
   *       obviously, if the return type is a SAM type, and the return value is a JavaScript
   *       function, a proxy object implementing the SAM type and delegating to the function will be
   *       returned.
   * </ul>
   *
   * @param opDesc Dynalink dynamic operation descriptor.
   * @param rtype the return type for the operation
   * @param ptypes the parameter types for the operation
   * @return MethodHandle for invoking the operation.
   */
  public static MethodHandle createDynamicInvoker(
      final String opDesc, final Class<?> rtype, final Class<?>... ptypes) {
    return createDynamicInvoker(opDesc, MethodType.methodType(rtype, ptypes));
  }

  /**
   * Returns a dynamic invoker for a specified dynamic operation using the public lookup. Similar to
   * {@link #createDynamicInvoker(String, Class, Class...)} but with an additional parameter to set
   * the call site flags of the dynamic invoker.
   *
   * @param opDesc Dynalink dynamic operation descriptor.
   * @param flags the call site flags for the operation
   * @param rtype the return type for the operation
   * @param ptypes the parameter types for the operation
   * @return MethodHandle for invoking the operation.
   */
  public static MethodHandle createDynamicInvoker(
      final String opDesc, final int flags, final Class<?> rtype, final Class<?>... ptypes) {
    return bootstrap(
            MethodHandles.publicLookup(), opDesc, MethodType.methodType(rtype, ptypes), flags)
        .dynamicInvoker();
  }

  /**
   * Returns a dynamic invoker for a specified dynamic operation using the public lookup. Similar to
   * {@link #createDynamicInvoker(String, Class, Class...)} but with return and parameter types
   * composed into a method type in the signature. See the discussion of that method for details.
   *
   * @param opDesc Dynalink dynamic operation descriptor.
   * @param type the method type for the operation
   * @return MethodHandle for invoking the operation.
   */
  public static MethodHandle createDynamicInvoker(final String opDesc, final MethodType type) {
    return bootstrap(MethodHandles.publicLookup(), opDesc, type, 0).dynamicInvoker();
  }

  /**
   * Binds any object Nashorn can use as a [[Callable]] to a receiver and optionally arguments.
   *
   * @param callable the callable to bind
   * @param boundThis the bound "this" value.
   * @param boundArgs the bound arguments. Can be either null or empty array to signify no arguments
   *     are bound.
   * @return a bound callable.
   * @throws ECMAException with {@code TypeError} if the object is not a callable.
   */
  public static Object bindCallable(
      final Object callable, final Object boundThis, final Object[] boundArgs) {
    if (callable instanceof ScriptFunction) {
      return ((ScriptFunction) callable).createBound(boundThis, boundArgs);
    } else if (callable instanceof BoundCallable) {
      return ((BoundCallable) callable).bind(boundArgs);
    } else if (isCallable(callable)) {
      return new BoundCallable(callable, boundThis, boundArgs);
    }
    throw notFunction(callable);
  }

  /**
   * Creates a super-adapter for an adapter, that is, an adapter to the adapter that allows
   * invocation of superclass methods on it.
   *
   * @param adapter the original adapter
   * @return a new adapter that can be used to invoke super methods on the original adapter.
   */
  public static Object createSuperAdapter(final Object adapter) {
    return new JavaSuperAdapter(adapter);
  }

  /**
   * If the given class is a reflection-specific class (anything in {@code java.lang.reflect} and
   * {@code java.lang.invoke} package, as well a {@link Class} and any subclass of {@link
   * ClassLoader}) and there is a security manager in the system, then it checks the {@code
   * nashorn.JavaReflection} {@code RuntimePermission}.
   *
   * @param clazz the class being tested
   * @param isStatic is access checked for static members (or instance members)
   */
  public static void checkReflectionAccess(final Class<?> clazz, final boolean isStatic) {
    ReflectionCheckLinker.checkReflectionAccess(clazz, isStatic);
  }

  /**
   * Returns the Nashorn's internally used dynamic linker's services object. Note that in code that
   * is processing a linking request, you will normally use the {@code LinkerServices} object passed
   * by whatever top-level linker invoked the linking (if the call site is in Nashorn-generated
   * code, you'll get this object anyway). You should only resort to retrieving a linker services
   * object using this method when you need some linker services (e.g. type converter method
   * handles) outside of a code path that is linking a call site.
   *
   * @return Nashorn's internal dynamic linker's services object.
   */
  public static LinkerServices getLinkerServices() {
    return dynamicLinker.getLinkerServices();
  }

  /**
   * Takes a guarded invocation, and ensures its method and guard conform to the type of the call
   * descriptor, using all type conversions allowed by the linker's services. This method is used by
   * Nashorn's linkers as a last step before returning guarded invocations. Most of the code used to
   * produce the guarded invocations does not make an effort to coordinate types of the methods, and
   * so a final type adjustment before a guarded invocation is returned to the aggregating linker is
   * the responsibility of the linkers themselves.
   *
   * @param inv the guarded invocation that needs to be type-converted. Can be null.
   * @param linkerServices the linker services object providing the type conversions.
   * @param desc the call site descriptor to whose method type the invocation needs to conform.
   * @return the type-converted guarded invocation. If input is null, null is returned. If the input
   *     invocation already conforms to the requested type, it is returned unchanged.
   */
  static GuardedInvocation asTypeSafeReturn(
      final GuardedInvocation inv,
      final LinkerServices linkerServices,
      final CallSiteDescriptor desc) {
    return inv == null ? null : inv.asTypeSafeReturn(linkerServices, desc.getMethodType());
  }

  /**
   * Adapts the return type of the method handle with {@code explicitCastArguments} when it is an
   * unboxing conversion. This will ensure that nulls are unwrapped to false or 0.
   *
   * @param target the target method handle
   * @param newType the desired new type. Note that this method does not adapt the method handle
   *     completely to the new type, it only adapts the return type; this is allowed as per {@link
   *     DynamicLinkerFactory#setAutoConversionStrategy(MethodTypeConversionStrategy)}, which is
   *     what this method is used for.
   * @return the method handle with adapted return type, if it required an unboxing conversion.
   */
  private static MethodHandle unboxReturnType(final MethodHandle target, final MethodType newType) {
    final MethodType targetType = target.type();
    final Class<?> oldReturnType = targetType.returnType();
    final Class<?> newReturnType = newType.returnType();
    if (TypeUtilities.isWrapperType(oldReturnType)) {
      if (newReturnType.isPrimitive()) {
        // The contract of setAutoConversionStrategy is such that the difference between newType and
        // targetType
        // can only be JLS method invocation conversions.
        assert TypeUtilities.isMethodInvocationConvertible(oldReturnType, newReturnType);
        return MethodHandles.explicitCastArguments(
            target, targetType.changeReturnType(newReturnType));
      }
    } else if (oldReturnType == void.class && newReturnType == Object.class) {
      return MethodHandles.filterReturnValue(target, VOID_TO_OBJECT);
    }
    return target;
  }
}