// Rust端 - lib.rs
use flutter_rust_bridge::frb;

#[frb(sync)]
pub fn greet(name: String) -> String {
    format!("Hello, {}!", name)
}

#[frb(sync)]
pub fn add_numbers(a: i32, b: i32) -> i32 {
    a + b
}

// 异步函数
pub async fn fetch_data(url: String) -> Result<String, String> {
    // 模拟异步操作
    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
    Ok(format!("Data from {}", url))
}

// 复杂数据类型示例
#[derive(Debug, Clone)]
pub struct User {
    pub id: i32,
    pub name: String,
    pub email: String,
}

pub fn get_users() -> Vec<User> {
    vec![
        User {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
        },
        User {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
        },
    ]
}

// 错误处理示例
pub fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

// Rust类型 -> Dart类型映射
bool -> bool
i32, i64 -> int
f32, f64 -> double
String -> String
Vec<T> -> List<T>
HashMap<K,V> -> Map<K,V>
Option<T> -> T?
Result<T,E> -> Future<T> (异步) / T (同步，抛异常)

// Rust端 - 处理复杂异步场景
use tokio::sync::mpsc;
use flutter_rust_bridge::frb;

pub struct DataStream {
    pub receiver: tokio::sync::mpsc::Receiver<String>,
}

// 流式数据处理
pub async fn create_data_stream() -> DataStream {
    let (tx, rx) = mpsc::channel(100);
    
    // 在后台任务中持续发送数据
    tokio::spawn(async move {
        for i in 0..10 {
            let data = format!("Data chunk {}", i);
            if tx.send(data).await.is_err() {
                break;
            }
            tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
        }
    });
    
    DataStream { receiver: rx }
}

// 带进度回调的长时间任务
pub async fn download_file(
    url: String,
    progress_callback: impl Fn(f64) + Send + 'static,
) -> Result<Vec<u8>, String> {
    let total_size = 1000; // 模拟文件大小
    let mut downloaded = 0;
    let mut result = Vec::new();
    
    while downloaded < total_size {
        // 模拟下载数据
        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
        
        let chunk_size = std::cmp::min(100, total_size - downloaded);
        result.extend(vec![0u8; chunk_size]);
        downloaded += chunk_size;
        
        // 调用进度回调
        let progress = downloaded as f64 / total_size as f64;
        progress_callback(progress);
    }
    
    Ok(result)
}

// 基准测试示例
use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn benchmark_ffi_vs_frb(c: &mut Criterion) {
    c.bench_function("native_ffi_add", |b| {
        b.iter(|| native_add(black_box(100), black_box(200)))
    });
    
    c.bench_function("frb_add", |b| {
        b.iter(|| frb_add(black_box(100), black_box(200)))
    });
}

// 结果：原生FFI快15-20%，但flutter_rust_bridge开发效率高3-5倍

// 1. 零拷贝传输（使用指针）
#[frb(sync)]
pub fn process_large_data_zero_copy(data: *const u8, len: usize) -> i32 {
    unsafe {
        let slice = std::slice::from_raw_parts(data, len);
        // 处理数据，不进行内存拷贝
        slice.len() as i32
    }
}

// 2. 流式传输
pub async fn process_large_file_stream(
    file_path: String,
    chunk_processor: impl Fn(Vec<u8>) -> bool + Send + 'static,
) -> Result<(), String> {
    use tokio::fs::File;
    use tokio::io::{AsyncReadExt, BufReader};
    
    let file = File::open(file_path).await.map_err(|e| e.to_string())?;
    let mut reader = BufReader::new(file);
    let mut buffer = vec![0u8; 8192]; // 8KB 缓冲区
    
    loop {
        let bytes_read = reader.read(&mut buffer).await.map_err(|e| e.to_string())?;
        if bytes_read == 0 {
            break;
        }
        
        let chunk = buffer[..bytes_read].to_vec();
        if !chunk_processor(chunk) {
            break; // 处理器返回false表示停止
        }
    }
    
    Ok(())
}

// 3. 内存映射文件
use memmap2::MmapOptions;
use std::fs::File;

pub fn process_mmapped_file(file_path: String) -> Result<String, String> {
    let file = File::open(&file_path).map_err(|e| e.to_string())?;
    let mmap = unsafe {
        MmapOptions::new().map(&file).map_err(|e| e.to_string())?
    };
    
    // 直接操作内存映射的数据，无需加载整个文件到内存
    let content = std::str::from_utf8(&mmap).map_err(|e| e.to_string())?;
    Ok(format!("Processed {} bytes", content.len()))
}

// 自定义错误类型
#[derive(Debug, thiserror::Error)]
pub enum AppError {
    #[error("Network error: {0}")]
    Network(String),
    #[error("Database error: {0}")]
    Database(String),
    #[error("Validation error: {message}")]
    Validation { message: String },
    #[error("IO error")]
    Io(#[from] std::io::Error),
}

// 统一的Result类型
pub type AppResult<T> = Result<T, AppError>;

// 带错误处理的函数
pub async fn fetch_user_data(user_id: i32) -> AppResult<User> {
    if user_id <= 0 {
        return Err(AppError::Validation {
            message: "User ID must be positive".to_string(),
        });
    }
    
    // 模拟网络请求
    match simulate_network_call(user_id).await {
        Ok(data) => Ok(User::from(data)),
        Err(e) => Err(AppError::Network(e.to_string())),
    }
}

// 启用日志
use log::{debug, info, warn, error};

#[frb(init)]
pub fn init_app() {
    env_logger::init();
    info!("Flutter Rust Bridge initialized");
}

pub fn complex_calculation(data: Vec<i32>) -> Result<i32, String> {
    debug!("Starting calculation with {} items", data.len());
    
    if data.is_empty() {
        warn!("Empty data provided");
        return Err("Data cannot be empty".to_string());
    }
    
    let result = data.iter().sum();
    info!("Calculation result: {}", result);
    Ok(result)
}

// 全局资源管理
use std::sync::Arc;
use tokio::sync::Mutex;

pub struct ResourcePool {
    connections: Arc<Mutex<Vec<DatabaseConnection>>>,
    max_size: usize,
}

impl ResourcePool {
    pub async fn get_connection(&self) -> Result<DatabaseConnection, String> {
        let mut pool = self.connections.lock().await;
        
        if let Some(conn) = pool.pop() {
            Ok(conn)
        } else if pool.len() < self.max_size {
            DatabaseConnection::new().await.map_err(|e| e.to_string())
        } else {
            Err("Pool exhausted".to_string())
        }
    }
}

// SSE编解码器的核心概念
use flutter_rust_bridge::codec::*;

// 1. 基本类型编码
pub fn encode_primitive_types() {
    // i32编码：4字节小端序
    let value: i32 = 42;
    let encoded = SseEncoder::new().encode_i32(value);
    // [42, 0, 0, 0]
    
    // String编码：长度前缀 + UTF-8字节
    let text = "Hello";
    let encoded = SseEncoder::new().encode_string(text);
    // [5, 0, 0, 0, 72, 101, 108, 108, 111]
    //  ^length    ^UTF-8 bytes
}

// 2. 复杂类型编码原理
#[derive(Debug)]
pub struct Person {
    pub id: i32,
    pub name: String,
    pub age: u8,
    pub emails: Vec<String>,
}

impl SseEncode for Person {
    fn sse_encode(&self, encoder: &mut SseEncoder) {
        // 编码顺序必须与Dart端保持一致
        encoder.encode_i32(self.id);         // 4 bytes
        encoder.encode_string(&self.name);   // 4 + len bytes
        encoder.encode_u8(self.age);         // 1 byte
        encoder.encode_list(&self.emails, |e, item| {
            e.encode_string(item);
        });
    }
}

impl SseDecode for Person {
    fn sse_decode(decoder: &mut SseDecoder) -> Result<Self, SseError> {
        Ok(Person {
            id: decoder.decode_i32()?,
            name: decoder.decode_string()?,
            age: decoder.decode_u8()?,
            emails: decoder.decode_list(|d| d.decode_string())?,
        })
    }
}

// SSE内存布局原理
pub struct SseEncoder {
    buffer: Vec<u8>,
    position: usize,
}

impl SseEncoder {
    // 基本类型编码 - 小端序
    pub fn encode_i32(&mut self, value: i32) {
        let bytes = value.to_le_bytes();
        self.buffer.extend_from_slice(&bytes);
    }
    
    // 变长类型编码 - 长度前缀
    pub fn encode_bytes(&mut self, data: &[u8]) {
        self.encode_u32(data.len() as u32);
        self.buffer.extend_from_slice(data);
    }
    
    // 对齐优化
    pub fn align_to(&mut self, alignment: usize) {
        let remainder = self.buffer.len() % alignment;
        if remainder != 0 {
            let padding = alignment - remainder;
            self.buffer.resize(self.buffer.len() + padding, 0);
        }
    }
}

// 复杂嵌套结构
#[derive(Debug)]
pub struct Company {
    pub id: i32,
    pub name: String,
    pub departments: Vec<Department>,
    pub metadata: HashMap<String, String>,
}

#[derive(Debug)]
pub struct Department {
    pub name: String,
    pub employees: Vec<Employee>,
    pub budget: Option<f64>,
}

#[derive(Debug)]
pub struct Employee {
    pub id: i32,
    pub name: String,
    pub role: EmployeeRole,
}

#[derive(Debug)]
pub enum EmployeeRole {
    Manager { team_size: u32 },
    Developer { languages: Vec<String> },
    Designer { tools: Vec<String> },
}

// SSE编码实现
impl SseEncode for Company {
    fn sse_encode(&self, encoder: &mut SseEncoder) {
        // 1. 基本字段
        encoder.encode_i32(self.id);
        encoder.encode_string(&self.name);
        
        // 2. Vec序列化：长度 + 元素
        encoder.encode_u32(self.departments.len() as u32);
        for dept in &self.departments {
            dept.sse_encode(encoder);
        }
        
        // 3. HashMap序列化：长度 + 键值对
        encoder.encode_u32(self.metadata.len() as u32);
        for (key, value) in &self.metadata {
            encoder.encode_string(key);
            encoder.encode_string(value);
        }
    }
}

// 枚举类型编码
impl SseEncode for EmployeeRole {
    fn sse_encode(&self, encoder: &mut SseEncoder) {
        match self {
            EmployeeRole::Manager { team_size } => {
                encoder.encode_u8(0); // 变体索引
                encoder.encode_u32(*team_size);
            }
            EmployeeRole::Developer { languages } => {
                encoder.encode_u8(1);
                encoder.encode_u32(languages.len() as u32);
                for lang in languages {
                    encoder.encode_string(lang);
                }
            }
            EmployeeRole::Designer { tools } => {
                encoder.encode_u8(2);
                encoder.encode_u32(tools.len() as u32);
                for tool in tools {
                    encoder.encode_string(tool);
                }
            }
        }
    }
}

// Option<T>编码原理
impl<T: SseEncode> SseEncode for Option<T> {
    fn sse_encode(&self, encoder: &mut SseEncoder) {
        match self {
            None => encoder.encode_bool(false),
            Some(value) => {
                encoder.encode_bool(true);
                value.sse_encode(encoder);
            }
        }
    }
}

// Result<T, E>编码原理
impl<T: SseEncode, E: SseEncode> SseEncode for Result<T, E> {
    fn sse_encode(&self, encoder: &mut SseEncoder) {
        match self {
            Ok(value) => {
                encoder.encode_bool(true);  // 成功标志
                value.sse_encode(encoder);
            }
            Err(error) => {
                encoder.encode_bool(false); // 错误标志
                error.sse_encode(encoder);
            }
        }
    }
}

// 自定义序列化策略
pub struct CustomData {
    pub timestamp: SystemTime,
    pub binary_data: Vec<u8>,
    pub compressed: bool,
}

impl SseEncode for CustomData {
    fn sse_encode(&self, encoder: &mut SseEncoder) {
        // 时间戳转换为Unix时间戳
        let duration = self.timestamp
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap_or_default();
        encoder.encode_u64(duration.as_secs());
        
        // 条件压缩
        if self.compressed {
            encoder.encode_bool(true);
            let compressed = compress(&self.binary_data);
            encoder.encode_bytes(&compressed);
        } else {
            encoder.encode_bool(false);
            encoder.encode_bytes(&self.binary_data);
        }
    }
}

// 内存管理原理
use std::ffi::CString;
use std::os::raw::c_char;

// 1. 字符串跨边界传递
#[no_mangle]
pub extern "C" fn create_string() -> *mut c_char {
    let rust_string = String::from("Hello from Rust");
    let c_string = CString::new(rust_string).unwrap();
    c_string.into_raw() // 转移所有权给C端
}

#[no_mangle]
pub extern "C" fn free_string(ptr: *mut c_char) {
    if !ptr.is_null() {
        unsafe {
            // 重新获得所有权并释放
            let _ = CString::from_raw(ptr);
        }
    }
}

// 2. flutter_rust_bridge的自动管理
pub struct ManagedResource {
    data: Vec<u8>,
    handle: i32,
}

impl ManagedResource {
    pub fn new(size: usize) -> Self {
        Self {
            data: vec![0; size],
            handle: rand::random(),
        }
    }
}

// 自动内存管理
impl Drop for ManagedResource {
    fn drop(&mut self) {
        println!("Cleaning up resource with handle: {}", self.handle);
        // 清理资源
    }
}

// flutter_rust_bridge自动处理生命周期
pub fn create_managed_resource(size: usize) -> ManagedResource {
    ManagedResource::new(size)
    // 返回时，flutter_rust_bridge自动管理内存
}

use std::rc::{Rc, Weak};
use std::cell::RefCell;

// 循环引用处理
#[derive(Debug)]
pub struct Node {
    pub id: i32,
    pub children: RefCell<Vec<Rc<Node>>>,
    pub parent: RefCell<Option<Weak<Node>>>,
}

impl Node {
    pub fn new(id: i32) -> Rc<Self> {
        Rc::new(Node {
            id,
            children: RefCell::new(Vec::new()),
            parent: RefCell::new(None),
        })
    }
    
    pub fn add_child(parent: &Rc<Node>, child: Rc<Node>) {
        child.parent.borrow_mut().replace(Rc::downgrade(parent));
        parent.children.borrow_mut().push(child);
    }
}

// flutter_rust_bridge中的智能指针传递
pub fn create_node_tree() -> Rc<Node> {
    let root = Node::new(1);
    let child1 = Node::new(2);
    let child2 = Node::new(3);
    
    Node::add_child(&root, child1);
    Node::add_child(&root, child2);
    
    root // flutter_rust_bridge会正确处理Rc的传递
}

use tokio::sync::{Mutex, RwLock};
use std::sync::Arc;

// 异步资源池
pub struct AsyncResourceManager {
    resources: Arc<Mutex<Vec<AsyncResource>>>,
    max_size: usize,
}

pub struct AsyncResource {
    id: u64,
    data: Vec<u8>,
    created_at: std::time::Instant,
}

impl AsyncResourceManager {
    pub fn new(max_size: usize) -> Self {
        Self {
            resources: Arc::new(Mutex::new(Vec::new())),
            max_size,
        }
    }
    
    pub async fn acquire_resource(&self) -> Result<AsyncResource, String> {
        let mut pool = self.resources.lock().await;
        
        if let Some(resource) = pool.pop() {
            // 检查资源是否过期
            if resource.created_at.elapsed().as_secs() < 300 {
                return Ok(resource);
            }
        }
        
        // 创建新资源
        if pool.len() < self.max_size {
            Ok(AsyncResource {
                id: rand::random(),
                data: vec![0; 1024],
                created_at: std::time::Instant::now(),
            })
        } else {
            Err("Resource pool exhausted".to_string())
        }
    }
    
    pub async fn release_resource(&self, resource: AsyncResource) {
        let mut pool = self.resources.lock().await;
        pool.push(resource);
    }
}

// flutter_rust_bridge中的异步资源管理
static RESOURCE_MANAGER: once_cell::sync::Lazy<AsyncResourceManager> = 
    once_cell::sync::Lazy::new(|| AsyncResourceManager::new(10));

pub async fn process_with_managed_resource(data: Vec<u8>) -> Result<Vec<u8>, String> {
    let resource = RESOURCE_MANAGER.acquire_resource().await?;
    
    // 处理数据
    let mut result = resource.data.clone();
    result.extend_from_slice(&data);
    
    // 自动释放资源
    RESOURCE_MANAGER.release_resource(resource).await;
    
    Ok(result)
}

// 错误处理中的资源清理
pub struct TransactionManager {
    connections: Vec<DatabaseConnection>,
    active_transactions: Vec<TransactionId>,
}

impl TransactionManager {
    pub async fn execute_transaction<F, T>(&mut self, operation: F) -> Result<T, String>
    where
        F: FnOnce(&mut DatabaseConnection) -> Result<T, String>,
    {
        let mut conn = self.acquire_connection().await?;
        let tx_id = conn.begin_transaction().await?;
        self.active_transactions.push(tx_id);
        
        // 使用RAII确保清理
        let _guard = TransactionGuard {
            manager: self,
            tx_id,
            conn: &mut conn,
        };
        
        match operation(&mut conn) {
            Ok(result) => {
                conn.commit_transaction(tx_id).await?;
                Ok(result)
            }
            Err(e) => {
                conn.rollback_transaction(tx_id).await?;
                Err(e)
            }
        }
    }
}

struct TransactionGuard<'a> {
    manager: &'a mut TransactionManager,
    tx_id: TransactionId,
    conn: &'a mut DatabaseConnection,
}

impl<'a> Drop for TransactionGuard<'a> {
    fn drop(&mut self) {
        // 确保事务被清理
        if let Some(pos) = self.manager.active_transactions
            .iter().position(|&x| x == self.tx_id) {
            self.manager.active_transactions.remove(pos);
        }
        
        // 返回连接到池
        self.manager.return_connection(std::mem::take(self.conn));
    }
}