Flutter FFI 与 Rust 进阶实战

use std::panic::{catch_unwind, AssertUnwindSafe};

/// 所有可能 panic 的 extern "C" 导出函数都应包裹一层 panic 捕获防护 Guard
pub fn guard<T>(fallback: T, body: impl FnOnce() -> T) -> T {
    catch_unwind(AssertUnwindSafe(body)).unwrap_or(fallback)
}

#[no_mangle]
pub extern "C" fn rfd_add(a: i64, b: i64) -> i64 {
    a.wrapping_add(b) // wrapping_add 不会 panic，这里无需 guard
}

// 直接通过自动生成的 bindings 调用
int add(int a, int b) => bindings.rfd_add(a, b);

@Native<Int64 Function(Int64, Int64)>(symbol: 'rfd_add', isLeaf: true)
external int rfd_add(int a, int b);

@Native<Int64 Function(Pointer<Uint8>, Size)>(symbol: 'rfd_sum_buffer', isLeaf: true)
external int _sumBuffer(Pointer<Uint8> data, int len);

int sumBuffer(Uint8List data) {
  if (data.isEmpty) return 0;
  // 零拷贝：仅在这一次叶子调用期间有效
  return _sumBuffer(data.address, data.length);
}

int sumBufferCopied(Uint8List data) {
  if (data.isEmpty) return 0;
  final buffer = malloc<Uint8>(data.length); // 注意：malloc(0) 可能返回 nullptr
  try {
    buffer.asTypedList(data.length).setAll(0, data);
    return bindings.rfd_sum_buffer(buffer, data.length);
  } finally {
    malloc.free(buffer); // Dart 拥有此段分配的内存，负责在 finally 中释放
  }
}

#[no_mangle]
pub extern "C" fn rfd_blocking_sleep(millis: u64) -> u64 {
    guard(0, || {
        let start = std::time::Instant::now();
        std::thread::sleep(std::time::Duration::from_millis(millis));
        start.elapsed().as_millis() as u64
    })
}

// 注意：闭包会被发送到新 Isolate，捕获的变量必须是可发送的,否则会抛出 "Illegal argument in isolate message"。
Future<int> runInIsolate(Duration duration) =>
    Isolate.run(() => blockingSleep(duration));

if (_bindings.initialize_dart_api(dartffi.NativeApi.initializeApiDLData) != 0) {
  throw StateError(
    'failed to initialize Dart DL C API: version mismatch. '
    'must update include/ to match Dart SDK version',
  );
}

/// 返回 0 表示成功，非 0 表示失败。
/// # Safety
/// `api_data` 必须是 `NativeApi.initializeApiDLData` 传入的有效指针。
#[no_mangle]
pub unsafe extern "C" fn initialize_dart_api(
    api_data: *mut ::core::ffi::c_void,
) -> ::core::ffi::c_int {
    Dart_InitializeApiDL(api_data)
}

#[no_mangle]
pub extern "C" fn rfd_thread_sleep(port: i64, request_id: i64, millis: u64) {
    guard((), || {
        std::thread::spawn(move || {
            // guard 必须放在 worker 闭包**内部**
            let result = guard(Err("panic in worker".to_string()), || {
                let start = std::time::Instant::now();
                std::thread::sleep(std::time::Duration::from_millis(millis));
                Ok(start.elapsed().as_millis() as i64)
            });
            // 无论成功失败，都必须回传一次，向指定 native port 发送 [requestId, status, value]
            match result {
                Ok(v) => post_ok(port, request_id, v),
                Err(e) => post_err(port, request_id, &e),
            }
        });
    });
}

#[no_mangle]
pub extern "C" fn rfd_blocking_sleep_pool(port: i64, request_id: i64, millis: u64) {
    guard((), || {
        runtime().spawn_blocking(move || {
            // 同上：guard 下沉到任务体内，失败路径同样要回传
            let result = guard(Err("panic in blocking task".to_string()), || {
                let start = std::time::Instant::now();
                std::thread::sleep(std::time::Duration::from_millis(millis));
                Ok(start.elapsed().as_millis() as i64)
            });
            match result {
                Ok(v) => post_ok(port, request_id, v),
                Err(e) => post_err(port, request_id, &e),
            }
        });
    });
}

#[no_mangle]
pub extern "C" fn rfd_tokio_sleep(port: i64, request_id: i64, millis: u64) {
    guard((), || {
        runtime().spawn(async move {
            let start = std::time::Instant::now();
            tokio::time::sleep(std::time::Duration::from_millis(millis)).await;
            post_ok(port, request_id, start.elapsed().as_millis() as i64);
        });
    });
}

let handle = runtime().spawn(async move { /* ... 业务逻辑 ... */ });
runtime().spawn(async move {
    if let Err(e) = handle.await {
        // 任务 panic 或被取消
        post_err(port, request_id, &e.to_string());
    }
});

for index in 0..count {
    tokio::time::sleep(interval).await;
    // 当 Dart 端取消 Stream 并关闭 Port 时，post 会返回 false
    if !post(port, vec![request_id, STATUS_PROGRESS, index as i64]) {
        return; // Dart 端已取消，立即停止 Rust 端的生产，防止内存泄露
    }
}
post(port, vec![request_id, STATUS_DONE, count as i64]);

// Dart 侧每消费 N 条就通过 rfd_stream_credit(request_id, n) 补充配额
// Rust 侧在配额耗尽时 await 信号量，而不是继续闷头生产
credits.acquire().await;
post(port, vec![request_id, STATUS_PROGRESS, index as i64]);

final callable = NativeCallable<Int64 Function(Int64)>.isolateLocal(
  callback,
  exceptionalReturn: 0, // 编译期常量！当 Dart 发生未捕获异常时的默认返回值
);
try {
  return bindings.rfd_map_with_callback(callable.nativeFunction, seed, iterations);
} finally {
  callable.close(); // 必须显式关闭！
}

// 错误：FFI 调用返回不代表回调已经执行完
try {
  bindings.rfd_run_async(callable.nativeFunction);
} finally {
  callable.close(); // 回调还没来得及投递就被关掉了
}

use std::cell::RefCell;
use std::panic::{catch_unwind, AssertUnwindSafe};

thread_local! {
    static LAST_PANIC: RefCell<Option<String>> = const { RefCell::new(None) };
}

pub fn guard<T>(fallback: T, body: impl FnOnce() -> T) -> T {
    match catch_unwind(AssertUnwindSafe(body)) {
        Ok(val) => val,
        Err(err) => {
            let msg = if let Some(s) = err.downcast_ref::<&str>() {
                s.to_string()
            } else if let Some(s) = err.downcast_ref::<String>() {
                s.clone()
            } else {
                "Unknown Rust panic".to_string()
            };
            LAST_PANIC.with(|slot| *slot.borrow_mut() = Some(msg));
            fallback
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct RfdBuffer {
    pub ptr: *mut u8,
    pub len: usize,
    pub cap: usize, // 必须携带 capacity，原因见下
}

impl RfdBuffer {
    const fn empty() -> Self {
        Self { ptr: std::ptr::null_mut(), len: 0, cap: 0 }
    }

    fn from_vec(mut v: Vec<u8>) -> Self {
        let (ptr, len, cap) = (v.as_mut_ptr(), v.len(), v.capacity());
        std::mem::forget(v); // 交出所有权：Rust 不再负责释放这块内存
        Self { ptr, len, cap }
    }
}

/// 分配一块交由 Dart 负责释放的缓冲区。
#[no_mangle]
pub extern "C" fn rfd_buffer_new(len: u32, fill: u8) -> RfdBuffer {
    guard(RfdBuffer::empty(), || {
        RfdBuffer::from_vec(vec![fill; len as usize])
    })
}

/// # Safety
/// `buffer` 必须来自 `rfd_buffer_new`，且只能被释放一次。
#[no_mangle]
pub unsafe extern "C" fn rfd_buffer_free(buffer: RfdBuffer) {
    guard((), || {
        if buffer.ptr.is_null() { return; }
        // 用原始的 (ptr, len, cap) 三元组还原 Vec，layout 才对得上
        drop(Vec::from_raw_parts(buffer.ptr, buffer.len, buffer.cap));
    });
}

final class RustBuffer {
  RustBuffer._(this._raw);

  factory RustBuffer.allocate(int length, {int fill = 0}) {
    final raw = bindings.rfd_buffer_new(length, fill);
    if (raw.ptr == nullptr && length > 0) {
      throw StateError('rfd_buffer_new 返回了空指针');
    }
    return RustBuffer._(raw);
  }

  final bindings.RfdBuffer _raw;
  bool _freed = false;

  /// 零拷贝视图：直接映射 Rust 内存，free() 之后立即失效
  Uint8List get bytes {
    if (_freed) throw StateError('RustBuffer 已被释放');
    if (_raw.ptr == nullptr) return Uint8List(0);
    return _raw.ptr.asTypedList(_raw.len);
  }

  /// 幂等：重复调用不会造成 double free
  void free() {
    if (_freed) return;
    _freed = true;
    bindings.rfd_buffer_free(_raw);
  }
}

// 调用方必须自己保证 free 一定发生
final buffer = RustBuffer.allocate(1024, fill: 7);
try {
  process(buffer.bytes);
} finally {
  buffer.free();
}

// 危险：仅当 cap == len 时才正确
drop(Box::from_raw(std::slice::from_raw_parts_mut(buffer.ptr, buffer.len)));

use std::ffi::c_void;

pub struct RfdSession {
    state: u64,
    buffer: Vec<u8>,
}

#[no_mangle]
pub extern "C" fn rfd_session_new(seed: u64) -> *mut RfdSession {
    guard(std::ptr::null_mut(), || {
        Box::into_raw(Box::new(RfdSession {
            state: seed,
            buffer: vec![0u8; 64 * 1024],
        }))
    })
}

/// # Safety
/// `session` 必须来自 `rfd_session_new`，且只能被释放一次。
#[no_mangle]
pub unsafe extern "C" fn rfd_session_free(session: *mut c_void) {
    guard((), || {
        if session.is_null() { return; }
        drop(Box::from_raw(session as *mut RfdSession));
    });
}

final _sessionFinalizer = NativeFinalizer(
  bindings.addresses.rfd_session_free.cast(),
);

final class RustSession implements Finalizable {
  RustSession({int seed = 0, this.bufferLength = 64 * 1024})
      : _handle = bindings.rfd_session_new(seed) {
    if (_handle == nullptr) throw StateError('rfd_session_new 返回了空指针');
    // 把 Dart 对象的生命周期与 Native 指针绑定：
    // 本对象不可达时，VM 会以 _handle 为参数调用 rfd_session_free
    _sessionFinalizer.attach(this, _handle.cast(),
        detach: this, externalSize: bufferLength);
  }

  final int bufferLength;
  final Pointer<bindings.RfdSession> _handle;
  bool _closed = false;

  int next() {
    if (_closed) throw StateError('RustSession 已关闭');
    return bindings.rfd_session_next(_handle);
  }

  /// 提前释放，不等 GC。幂等。
  void close() {
    if (_closed) return;
    _closed = true;
    _sessionFinalizer.detach(this); // 必须先 detach，否则将来会二次释放
    bindings.rfd_session_free(_handle.cast());
  }
}

/// 借来的视图：只有 ptr 与 len，没有 cap——因为调用方无权释放它。
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RfdBufferView {
    pub ptr: *const u8,
    pub len: usize,
}

/// 填充 session 内部缓冲区并返回其视图：不分配、不拷贝。
///
/// # Safety
/// `session` 必须是存活的 session 指针；返回的视图仅在该 session 存活期间有效。
#[no_mangle]
pub unsafe extern "C" fn rfd_session_fill(session: *mut RfdSession, seed: u8) -> RfdBufferView {
    guard(RfdBufferView { ptr: std::ptr::null(), len: 0 }, || {
        let Some(session) = session.as_mut() else {
            return RfdBufferView { ptr: std::ptr::null(), len: 0 };
        };
        for (index, byte) in session.buffer.iter_mut().enumerate() {
            *byte = seed.wrapping_add(index as u8);
        }
        RfdBufferView { ptr: session.buffer.as_ptr(), len: session.buffer.len() }
    })
}

final class RustSession implements Finalizable {
  // ...

  /// 必须是 Finalizable 类的**实例方法**，不能写成接收裸指针的顶层函数
  Uint8List fillBuffer(int seed) {
    if (_closed) throw StateError('RustSession 已关闭');
    final view = bindings.rfd_session_fill(_handle, seed);
    if (view.ptr == nullptr) return Uint8List(0);
    // 直接映射 Rust 内存
    return view.ptr.asTypedList(view.len);
  }
}

// 危险：session 对象可能在调用执行到一半时被 GC
Uint8List fillBuffer(Pointer<RfdSession> session, int seed) { ... }
// 调用方：fillBuffer(mySession._handle, 0);

#[no_mangle]
pub extern "C" fn rfd_post_zero_copy(port: i64, request_id: i64, len: u32) -> bool {
    guard(false, || {
        let bytes = vec![0u8; len as usize];
        // ZeroCopyBuffer 会把 Vec 转成 kExternalTypedData 类型的 Dart_CObject：
        //   data     = Vec 的指针
        //   peer     = 被 leak 出去的 Box<Vec<u8>>
        //   callback = VM 回收对应 Uint8List 时调用的释放函数
        post(port, (request_id, ZeroCopyBuffer(bytes)))
    })
}

Future<Uint8List> receiveZeroCopyBuffer(int length) async {
  final port = ReceivePort();
  try {
    final reply = port.first;
    if (!bindings.rfd_post_zero_copy(port.sendPort.nativePort, 0, length)) {
      throw StateError('投递失败：port 已关闭或 Dart API 未初始化');
    }
    final message = await reply as List<Object?>;
    // 拿到的是真正的 Uint8List，背后却是 Rust 那块内存，没有发生拷贝
    return message[1] as Uint8List;
  } finally {
    port.close();
  }
}