import Foundation

/// Name of the JavaScript thread created by React Native. Copied from `RCTJSThreadManager.mm`.
private let jsThreadName = "com.facebook.react.runtime.JavaScript"

/// Global actor that is used to isolate the code that should only be executed from the JavaScript thread.
/// Theoretically it does not act as a real actor; it uses a serial executor that executes jobs **synchronously**
/// without hopping to the proper thread. Meaning that running these jobs on the JavaScript thread must be ensured
/// externally before switching to the isolated context, e.g. using `schedule` function on `JavaScriptRuntime`
/// or enforcing the isolation with `JavaScriptActor.assumeIsolated`.
@globalActor
public actor JavaScriptActor: GlobalActor {
  public static let shared = JavaScriptActor()

  private init() {}

  nonisolated private let executor = JavaScriptExecutor()

  nonisolated public var unownedExecutor: UnownedSerialExecutor {
    return executor.asUnownedSerialExecutor()
  }

  /// An equivalent of `MainActor.assumeIsolated`, but for the `JavaScriptActor`. Assumes that the currently executing
  /// synchronous function is actually executing on the JavaScript thread and invokes an isolated version of the operation,
  /// allowing synchronous access to JavaScript runtime state without hopping through asynchronous boundaries.
  ///
  /// See https://stackoverflow.com/a/79346971 for more information about the implementation.
  public static func assumeIsolated<T: ~Copyable>(_ operation: @JavaScriptActor () throws -> T) rethrows -> T {
    typealias YesActor = @JavaScriptActor () throws -> T
    typealias NoActor = () throws -> T

    // This will crash if the current context cannot be isolated.
    shared.executor.checkIsolated()

    // To do the unsafe cast, we have to pretend it's @escaping.
    return try withoutActuallyEscaping(operation) { (_ fn: @escaping YesActor) throws -> T in
      let rawFn = unsafeBitCast(fn, to: NoActor.self)
      return try rawFn()
    }
  }

  /// Stops program execution if the actor's executor is not isolating the current context.
  public static func checkIsolated() {
    shared.executor.checkIsolated()
  }
}

/// Executor for the `JavaScriptActor` that executes given jobs synchronously and immediately.
/// - Note: It does not ensure that given jobs are executed on the JavaScript thread; it must be done externally.
internal class JavaScriptExecutor: SerialExecutor, @unchecked Sendable {
  func enqueue(_ job: UnownedJob) {
    job.runSynchronously(on: self.asUnownedSerialExecutor())
  }

  /// Converts the executor to the optimized form of borrowed executor reference.
  func asUnownedSerialExecutor() -> UnownedSerialExecutor {
    return UnownedSerialExecutor(ordinary: self)
  }

  /// Stops program execution if the executor is not isolating the current context.
  func checkIsolated() {
    // Using `assert` instead of `precondition` because this check is a heuristic based on
    // thread name, not a precise isolation guarantee. Worklet runtimes legitimately run on
    // the UI thread, which would cause a false-positive crash with `precondition`.
    assert(isIsolatingCurrentContext() == true, "JavaScriptActor operations must be run on the JavaScript thread")
  }

  /// Checks whether the executor isolates the current context, i.e. the current thread is a JavaScript thread.
  /// The condition is also met when running tests and in single threaded environments.
  func isIsolatingCurrentContext() -> Bool? {
    // We must be careful as it relies on the thread name given by React Native.
    return Thread.current.name == jsThreadName || !Thread.isMultiThreaded()
      || ProcessInfo.processInfo.processName == "xctest"
  }
}

/// An actor that is dedicated for the specific runtime.
internal actor JavaScriptRuntimeActor {
  private weak let runtime: JavaScriptRuntime?
  nonisolated private let executor: JavaScriptExecutor

  init(runtime: JavaScriptRuntime) {
    self.runtime = runtime
    self.executor = JavaScriptRuntimeExecutor(runtime: runtime)
  }

  nonisolated var unownedExecutor: UnownedSerialExecutor {
    return executor.asUnownedSerialExecutor()
  }

  func execute<R: Sendable>(_ operation: @escaping @JavaScriptActor () async throws -> R) async rethrows -> sending R {
    return try await operation()
  }
}

/// Serial executor dedicated for the specific runtime.
internal final class JavaScriptRuntimeExecutor: JavaScriptExecutor, @unchecked Sendable {
  private weak let runtime: JavaScriptRuntime?

  init(runtime: JavaScriptRuntime) {
    self.runtime = runtime
  }

  override func enqueue(_ job: UnownedJob) {
    runtime?.schedule(priority: .immediate) {
      job.runSynchronously(on: self.asUnownedSerialExecutor())
    }
  }
}