// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

// Dart test program for testing dart:ffi async callbacks.
//
// VMOptions=
// VMOptions=--stacktrace-every=100
// VMOptions=--use-slow-path
// VMOptions=--use-slow-path --stacktrace-every=100
// VMOptions=--dwarf_stack_traces --no-retain_function_objects --no-retain_code_objects
// VMOptions=--test_il_serialization
// VMOptions=--profiler --profile_vm=true
// VMOptions=--profiler --profile_vm=false
// SharedObjects=ffi_test_functions

import 'dart:async';
import 'dart:ffi';
import 'dart:isolate';

import "package:expect/expect.dart";

import 'dylib_utils.dart';

main(args, message) async {
  testNativeCallableStatic();
  testNativeCallableClosure();
  testNativeCallableDoubleCloseError();
  testNativeCallableNestedCloseCallStatic();
  testNativeCallableNestedCloseCallClosure();
  testNativeCallableExceptionalReturnStatic();
  testNativeCallableExceptionalReturnClosure();
  await testNativeCallableDontKeepAliveStatic();
  await testNativeCallableDontKeepAliveClosure();
  testNativeCallableKeepAliveGetter();
  print("All tests completed :)");
}

final ffiTestFunctions = dlopenPlatformSpecific("ffi_test_functions");

typedef TwoIntFnNativeType = Int32 Function(Pointer, Int32, Int32);
typedef TwoIntFnType = int Function(Pointer, int, int);
final callTwoIntFunction = ffiTestFunctions
    .lookupFunction<TwoIntFnNativeType, TwoIntFnType>("CallTwoIntFunction");

typedef CallbackNativeType = Int32 Function(Int32, Int32);
int add(int a, int b) {
  return a + b;
}

testNativeCallableStatic() {
  final callback = NativeCallable<CallbackNativeType>.isolateLocal(add,
      exceptionalReturn: 0);

  Expect.equals(1234, callTwoIntFunction(callback.nativeFunction, 1000, 234));

  callback.close();
}

testNativeCallableClosure() {
  int c = 70000;

  final callback = NativeCallable<CallbackNativeType>.isolateLocal(
      (int a, int b) => a + b + c,
      exceptionalReturn: 0);

  Expect.equals(71234, callTwoIntFunction(callback.nativeFunction, 1000, 234));

  c = 80000;
  Expect.equals(81234, callTwoIntFunction(callback.nativeFunction, 1000, 234));

  callback.close();
}

testNativeCallableDoubleCloseError() {
  final callback = NativeCallable<CallbackNativeType>.isolateLocal(add,
      exceptionalReturn: 0);
  Expect.notEquals(nullptr, callback.nativeFunction);
  callback.close();

  Expect.throwsStateError(() {
    final _ = callback.nativeFunction;
  });

  // Expect that these do not throw.
  callback.close();
  callback.keepIsolateAlive = true;
  Expect.isFalse(callback.keepIsolateAlive);
}

late NativeCallable selfClosingStaticCallback;
int selfClosingStatic(int a, int b) {
  selfClosingStaticCallback.close();
  return a + b;
}

testNativeCallableNestedCloseCallStatic() {
  selfClosingStaticCallback = NativeCallable<CallbackNativeType>.isolateLocal(
      selfClosingStatic,
      exceptionalReturn: 0);

  Expect.equals(1234,
      callTwoIntFunction(selfClosingStaticCallback.nativeFunction, 1000, 234));

  // The callback is already closed.
  Expect.throwsStateError(() {
    final _ = selfClosingStaticCallback.nativeFunction;
  });
}

testNativeCallableNestedCloseCallClosure() {
  late NativeCallable callback;

  callback = NativeCallable<CallbackNativeType>.isolateLocal((int a, int b) {
    callback.close();
    return a + b;
  }, exceptionalReturn: 0);

  Expect.equals(1234, callTwoIntFunction(callback.nativeFunction, 1000, 234));

  // The callback is already closed.
  Expect.throwsStateError(() {
    final _ = callback.nativeFunction;
  });
}

int throwerCallback(int a, int b) {
  if (a != 1000) {
    throw "Oh no!";
  }
  return a + b;
}

testNativeCallableExceptionalReturnStatic() {
  final callback = NativeCallable<CallbackNativeType>.isolateLocal(
      throwerCallback,
      exceptionalReturn: 5678);

  Expect.equals(1234, callTwoIntFunction(callback.nativeFunction, 1000, 234));
  Expect.equals(5678, callTwoIntFunction(callback.nativeFunction, 0, 0));

  callback.close();
}

testNativeCallableExceptionalReturnClosure() {
  final callback =
      NativeCallable<CallbackNativeType>.isolateLocal((int a, int b) {
    if (a != 1000) {
      throw "Oh no!";
    }
    return a + b;
  }, exceptionalReturn: 5678);

  Expect.equals(1234, callTwoIntFunction(callback.nativeFunction, 1000, 234));
  Expect.equals(5678, callTwoIntFunction(callback.nativeFunction, 0, 0));

  callback.close();
}

Future<void> testNativeCallableDontKeepAliveStatic() async {
  final exitPort = ReceivePort();
  await Isolate.spawn((_) async {
    final callback = NativeCallable<CallbackNativeType>.isolateLocal(add,
        exceptionalReturn: 0);

    Expect.equals(1234, callTwoIntFunction(callback.nativeFunction, 1000, 234));

    callback.keepIsolateAlive = false;
  }, null, onExit: exitPort.sendPort);
  await exitPort.first;
  exitPort.close();
}

Future<void> testNativeCallableDontKeepAliveClosure() async {
  int c = 70000;

  final exitPort = ReceivePort();
  await Isolate.spawn((_) async {
    final callback = NativeCallable<CallbackNativeType>.isolateLocal(
        (int a, int b) => a + b + c,
        exceptionalReturn: 0);

    Expect.equals(
        71234, callTwoIntFunction(callback.nativeFunction, 1000, 234));

    callback.keepIsolateAlive = false;
  }, null, onExit: exitPort.sendPort);
  await exitPort.first;
  exitPort.close();
}

testNativeCallableKeepAliveGetter() {
  final callback = NativeCallable<CallbackNativeType>.isolateLocal(add,
      exceptionalReturn: 0);
  // Check that only the flag changes are counted by decrementing and
  // incrementing a lot, and by different amounts.
  for (int i = 0; i < 100; ++i) {
    callback.keepIsolateAlive = false;
    Expect.isFalse(callback.keepIsolateAlive);
  }
  for (int i = 0; i < 200; ++i) {
    callback.keepIsolateAlive = true;
    Expect.isTrue(callback.keepIsolateAlive);
  }
  callback.close();
}