Rust: Rust 错误处理：Result 与 ? 运算符

// ============================================
// 用 Result 模拟点外卖的每一步
// ============================================

// 定义可能的错误
#[derive(Debug)]
enum OrderError {
    RestaurantNotFound,
    MenuLoadFailed,
    PaymentFailed(String),
    OrderCancelled,
}

// 模拟找店铺
fn find_restaurant(name: &str) -> Result<String, OrderError> {
    let available = vec!["PizzaHouse", "SushiBar", "NoodleShop"];
    if available.contains(&name) {
        Ok(format!("Found: {}", name))
    } else {
        Err(OrderError::RestaurantNotFound)
    }
}

// 模拟加载菜单
fn load_menu(restaurant: &str) -> Result<Vec<&str>, OrderError> {
    if restaurant.contains("Pizza") {
        Ok(vec!["Margherita", "Pepperoni", "Hawaiian"])
    } else {
        Err(OrderError::MenuLoadFailed)
    }
}

// 模拟支付
fn process_payment(amount: f64) -> Result<String, OrderError> {
    if amount < 100.0 {
        Ok(format!("Paid: ${:.2}", amount))
    } else {
        Err(OrderError::PaymentFailed("Insufficient balance".into()))
    }
}

fn main() {
    // 从头到尾跑一遍完整流程
    let restaurant = find_restaurant("PizzaHouse");
    match restaurant {
        Ok(msg) => println!("Step 1: {}", msg),
        Err(e) => println!("Step 1 failed: {:?}", e),
    }
}

// ============================================
// 用 Result 处理除法运算中的除零错误
// ============================================

fn safe_divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    // 用 match 处理成功和失败两种情况
    println!("=== match 处理 ===");
    match safe_divide(10.0, 2.0) {
        Ok(result) => println!("10 / 2 = {}", result),
        Err(msg) => println!("Error: {}", msg),
    }

    match safe_divide(10.0, 0.0) {
        Ok(result) => println!("10 / 0 = {}", result),
        Err(msg) => println!("Error: {}", msg),
    }

    // 用 unwrap_or 提供默认值
    println!("\n=== unwrap_or 默认值 ===");
    let result1 = safe_divide(10.0, 2.0).unwrap_or(0.0);
    let result2 = safe_divide(10.0, 0.0).unwrap_or(0.0);
    println!("10 / 2 = {}", result1);
    println!("10 / 0 = {} (default)", result2);

    // 用 unwrap_or_else 执行闭包
    println!("\n=== unwrap_or_else 闭包 ===");
    let result3 = safe_divide(10.0, 2.0).unwrap_or_else(|e| {
        eprintln!("Warning: {}, using default", e);
        0.0
    });
    println!("Result: {}", result3);

    // ⚠️ unwrap 会 panic（取消注释下面代码来体验）
    // let crash = safe_divide(10.0, 0.0).unwrap();
    // println!("Will not reach here");
}

=== match 处理 ===
10 / 2 = 5
Error: Division by zero

=== unwrap_or 默认值 ===
10 / 2 = 5
10 / 0 = 0 (default)

=== unwrap_or_else 闭包 ===
Result: 5

// ============================================
// ? 运算符：在 Result 间传播错误
// 只有在返回 Result 的函数中才能使用 ?
// ============================================

use std::fs::File;
use std::io::{self, Read};

// 读取文件的完整内容
// ? 表示：如果 File::open 失败，立即返回 Err
//         如果 read_to_string 失败，立即返回 Err
fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;          // 打开文件，失败就返回
    let mut content = String::new();
    file.read_to_string(&mut content)?;         // 读取内容，失败就返回
    Ok(content)
}

// 不使用 ? 的等价写法——代码量翻倍
fn read_file_without_question(path: &str) -> Result<String, io::Error> {
    let mut file = match File::open(path) {
        Ok(f) => f,
        Err(e) => return Err(e),
    };
    let mut content = String::new();
    match file.read_to_string(&mut content) {
        Ok(_) => Ok(content),
        Err(e) => Err(e),
    }
}

// 链式调用 ?——更简洁
fn read_file_chain(path: &str) -> Result<String, io::Error> {
    let mut content = String::new();
    File::open(path)?.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    // 分别测试读得到和读不到的文件
    let files = vec!["Cargo.toml", "nonexistent.txt"];

    for file in &files {
        match read_file(file) {
            Ok(content) => {
                println!("--- {} ({} bytes) ---", file, content.len());
                println!("{}", &content[..content.len().min(80)]);
            }
            Err(e) => {
                println!("Failed to read '{}': {}", file, e);
            }
        }
    }
}

--- Cargo.toml (42 bytes) ---
[package]
name = "demo"
version = "0.1.0"
edition = "2021"

Failed to read 'nonexistent.txt': The system cannot find the file specified. (os error 2)

// ============================================
// 自定义错误类型：让你的错误信息更丰富
// 需要实现 std::fmt::Display + std::fmt::Debug
// ============================================

use std::fmt;
use std::num::ParseIntError;

// 自定义错误枚举
#[derive(Debug)]
enum AppError {
    /// 输入为空
    EmptyInput,
    /// 解析数字失败，附带原始字符串
    ParseFailed(String),
    /// 数值超出允许范围
    OutOfRange { value: i32, min: i32, max: i32 },
    /// 除以零
    DivisionByZero,
}

// 实现 Display——控制用户看到的错误信息
impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AppError::EmptyInput => {
                write!(f, "Input cannot be empty")
            }
            AppError::ParseFailed(input) => {
                write!(f, "Failed to parse '{}' as a number", input)
            }
            AppError::OutOfRange { value, min, max } => {
                write!(f, "Value {} is out of range [{}, {}]", value, min, max)
            }
            AppError::DivisionByZero => {
                write!(f, "Division by zero is not allowed")
            }
        }
    }
}

// 实现 From<ParseIntError>——让 ? 运算符能自动转换
impl From<ParseIntError> for AppError {
    fn from(_: ParseIntError) -> Self {
        AppError::ParseFailed("unknown".into())
    }
}

// 处理用户输入：解析并验证
fn process_input(input: &str, divisor: i32) -> Result<i32, AppError> {
    if input.is_empty() {
        return Err(AppError::EmptyInput);
    }
    let value: i32 = input.parse().map_err(|_| {
        // 手动转换错误类型
        AppError::ParseFailed(input.to_string())
    })?;
    if value < -100 || value > 100 {
        return Err(AppError::OutOfRange {
            value,
            min: -100,
            max: 100,
        });
    }
    if divisor == 0 {
        return Err(AppError::DivisionByZero);
    }
    Ok(value / divisor)
}

fn main() {
    let test_cases = vec![
        ("42", 2,    "Normal case"),
        ("",   1,    "Empty input"),
        ("abc", 1,   "Parse error"),
        ("999", 1,   "Out of range"),
        ("50",  0,   "Division by zero"),
    ];

    for (input, divisor, description) in test_cases {
        match process_input(input, divisor) {
            Ok(result) => println!("[{}] OK: {}", description, result),
            Err(e) => println!("[{}] Error: {}", description, e),
        }
    }
}

[Normal case] OK: 21
[Empty input] Error: Input cannot be empty
[Parse error] Error: Failed to parse 'abc' as a number
[Out of range] Error: Value 999 is out of range [-100, 100]
[Division by zero] Error: Division by zero is not allowed

// ============================================
// 演示 panic! 和错误返回值的适用场景
// panic! → 不可恢复错误（Bug/断言失败）
// Result → 可恢复错误（用户输入/IO失败）
// ============================================

// --- 适合作 panic! 的场景 ---

/// 从配置文件中读取端口号
/// 如果配置文件缺失，这属于程序 Bug，panic 是合理的
fn get_default_port() -> u16 {
    // 这个值硬编码在代码中，不可能会解析失败
    "8080"
        .parse()
        .expect("Hardcoded port number is invalid")
}

/// 只接受正整数的函数
/// 传入负数说明调用方有 Bug，panic 快速暴露问题
fn sqrt_unchecked(x: i32) -> f64 {
    if x < 0 {
        panic!("sqrt_unchecked called with negative value: {}", x);
    }
    (x as f64).sqrt()
}

// --- 适合作 Result 的场景 ---

/// 从用户输入解析数字
/// 用户输入错误的格式是正常的，应当返回 Result
fn parse_user_input(input: &str) -> Result<i32, String> {
    input
        .parse()
        .map_err(|_| format!("'{}' is not a valid integer", input))
}

/// 计算身体质量指数（BMI）
/// 体重为 0 或负数是可能的数据错误，不是程序 Bug
fn calculate_bmi(weight_kg: f64, height_m: f64) -> Result<f64, String> {
    if weight_kg <= 0.0 {
        return Err("Weight must be positive".to_string());
    }
    if height_m <= 0.0 {
        return Err("Height must be positive".to_string());
    }
    Ok(weight_kg / (height_m * height_m))
}

fn main() {
    // 场景 1：panic 用于不可恢复错误
    println!("Default port: {}", get_default_port());

    // 场景 2：panic 用于断言——参数不合法
    let value = 16;
    println!("sqrt({}) = {}", value, sqrt_unchecked(value));

    // 场景 3：Result 用于可恢复错误——用户输入
    let inputs = vec!["42", "hello", "-5"];
    for input in inputs {
        match parse_user_input(input) {
            Ok(n) => println!("Parsed: {}", n),
            Err(e) => println!("Parse failed: {}", e),
        }
    }

    // 场景 4：Result 用于业务逻辑验证
    let bmi_cases = vec![
        (70.0, 1.75),
        (0.0, 1.70),
        (65.0, -0.5),
    ];
    for (weight, height) in bmi_cases {
        match calculate_bmi(weight, height) {
            Ok(bmi) => println!("BMI: {:.1}", bmi),
            Err(e) => println!("BMI error: {}", e),
        }
    }

    // 场景 5：expect 的 panic 信息帮助调试
    let numbers = vec![10, 20, 30];
    let first = numbers.first().expect("Vector should not be empty");
    println!("First element: {}", first);
}

Default port: 8080
sqrt(16) = 4
Parsed: 42
Parse failed: 'hello' is not a valid integer
Parsed: -5
BMI: 22.9
BMI error: Weight must be positive
BMI error: Height must be positive
First element: 10

// anyhow 风格（概念示例，不要求运行）
// use anyhow::{Context, Result};
//
// fn read_config() -> Result<String> {
//     let content = std::fs::read_to_string("config.toml")
//         .context("Failed to read config file")?;
//     Ok(content)
// }

// thiserror 风格（概念示例，不要求运行）
// use thiserror::Error;
//
// #[derive(Error, Debug)]
// enum MyError {
//     #[error("IO error: {0}")]
//     Io(#[from] std::io::Error),
//
//     #[error("Parse error: {0}")]
//     Parse(#[from] std::num::ParseIntError),
// }

// ============================================
// 综合示例：自定义错误 + ? 传播 + 恢复策略
// ============================================

use std::fmt;

#[derive(Debug)]
enum AppError {
    ParseError(String),
    ValidationError(String),
    NotFound(String),
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::ParseError(msg) => write!(f, "解析错误: {}", msg),
            AppError::ValidationError(msg) => write!(f, "验证错误: {}", msg),
            AppError::NotFound(msg) => write!(f, "未找到: {}", msg),
        }
    }
}

impl From<std::num::ParseIntError> for AppError {
    fn from(e: std::num::ParseIntError) -> Self {
        AppError::ParseError(e.to_string())
    }
}

fn parse_age(input: &str) -> Result<u8, AppError> {
    let age: u8 = input.parse().map_err(|_| AppError::ParseError(format!("'{}' 不是有效数字", input)))?;
    if age > 150 {
        return Err(AppError::ValidationError(format!("年龄 {} 不合理", age)));
    }
    Ok(age)
}

fn find_user(id: u32) -> Result<String, AppError> {
    let users = [(1, "Alice"), (2, "Bob"), (3, "Charlie")];
    users.iter()
        .find(|(uid, _)| *uid == id)
        .map(|(_, name)| name.to_string())
        .ok_or_else(|| AppError::NotFound(format!("用户 ID={}", id)))
}

fn process_user(id_str: &str, age_str: &str) -> Result<String, AppError> {
    let id: u32 = id_str.parse().map_err(|_| AppError::ParseError(format!("无效 ID: '{}'", id_str)))?;
    let age = parse_age(age_str)?;
    let name = find_user(id)?;
    Ok(format!("用户: {}, 年龄: {}", name, age))
}

fn main() {
    let test_cases = [
        ("1", "30"),
        ("2", "200"),
        ("5", "25"),
        ("abc", "30"),
        ("3", "abc"),
    ];

    println!("=== 用户处理测试 ===");
    for (id, age) in &test_cases {
        match process_user(id, age) {
            Ok(result) => println!("成功: {}", result),
            Err(e) => println!("失败: {}", e),
        }
    }

    println!("\n=== 批量处理（容错）===");
    let inputs = [("1", "30"), ("5", "25"), ("2", "abc"), ("3", "20")];
    let mut success_count = 0;
    for (id, age) in &inputs {
        match process_user(id, age) {
            Ok(result) => { println!("OK: {}", result); success_count += 1; }
            Err(e) => println!("跳过: {}", e),
        }
    }
    println!("成功: {}/{}", success_count, inputs.len());
}

=== 用户处理测试 ===
成功: 用户: Alice, 年龄: 30
失败: 验证错误: 年龄 200 不合理
失败: 未找到: 用户 ID=5
失败: 解析错误: 无效 ID: 'abc'
失败: 解析错误: 'abc' 不是有效数字

=== 批量处理（容错）===
OK: 用户: Alice, 年龄: 30
跳过: 未找到: 用户 ID=5
跳过: 解析错误: 'abc' 不是有效数字
OK: 用户: Charlie, 年龄: 20
成功: 2/4