Error Handling and Concurrency

use std::fs;
use std::io;
use std::num::ParseIntError;

// Result<T, E> — either Ok(value) or Err(error)
fn parse_number(s: &str) -> Result<i32, ParseIntError> {
    s.trim().parse::<i32>()   // returns Result<i32, ParseIntError>
}

// The ? operator — propagate error up the call stack
// If the value is Err, return early with that error
// If Ok, unwrap and continue
fn double_parse(s: &str) -> Result<i32, ParseIntError> {
    let n = s.trim().parse::<i32>()?;   // early return on parse error
    Ok(n * 2)
}

// File I/O with error handling
fn read_number_from_file(path: &str) -> Result<i32, io::Error> {
    let content = fs::read_to_string(path)?;    // Err propagated
    let n: i32 = content.trim().parse()
        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
    Ok(n)
}

fn main() {
    match parse_number("42") {
        Ok(n)  => println!("Parsed: {n}"),
        Err(e) => println!("Error: {e}"),
    }

    // unwrap() — panics on Err (use in tests/prototypes, not production)
    let n = parse_number("10").unwrap();

    // unwrap_or — default value on error
    let n = parse_number("bad").unwrap_or(0);

    // unwrap_or_else — compute default from the error
    let n = parse_number("bad").unwrap_or_else(|_| -1);

    // map and and_then for chaining
    let doubled = parse_number("21")
        .map(|n| n * 2);      // Ok(42) if parse succeeds
}

use std::fmt;

// Manual error type
#[derive(Debug)]
enum AppError {
    Io(std::io::Error),
    Parse(std::num::ParseIntError),
    InvalidInput(String),
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::Io(e)          => write!(f, "IO error: {e}"),
            AppError::Parse(e)       => write!(f, "Parse error: {e}"),
            AppError::InvalidInput(s) => write!(f, "Invalid input: {s}"),
        }
    }
}

// From conversions — enables ? to auto-convert error types
impl From<std::io::Error> for AppError {
    fn from(e: std::io::Error) -> Self { AppError::Io(e) }
}
impl From<std::num::ParseIntError> for AppError {
    fn from(e: std::num::ParseIntError) -> Self { AppError::Parse(e) }
}

// With the From impls, ? auto-converts io::Error and ParseIntError to AppError
fn load_and_parse(path: &str) -> Result<i32, AppError> {
    let content = std::fs::read_to_string(path)?;   // io::Error -> AppError::Io
    let n: i32 = content.trim().parse()?;           // ParseIntError -> AppError::Parse
    if n < 0 {
        return Err(AppError::InvalidInput("Negative numbers not allowed".into()));
    }
    Ok(n)
}

use std::thread;
use std::sync::{Arc, Mutex};

fn main() {
    // Spawn a thread — closure captures environment
    let handle = thread::spawn(|| {
        println!("Hello from a thread!");
    });
    handle.join().unwrap();   // wait for thread to finish

    // Move closure — transfer ownership of variables into thread
    let data = vec![1, 2, 3];
    let handle = thread::spawn(move || {
        println!("data: {:?}", data);   // data moved into thread
    });
    handle.join().unwrap();

    // Arc<Mutex<T>> — shared mutable state across threads
    // Arc = Atomically Reference Counted (thread-safe Rc)
    // Mutex = mutual exclusion lock
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut num = counter.lock().unwrap();  // acquire lock
            *num += 1;
        }));  // lock released here when `num` goes out of scope (RAII)
    }

    for h in handles { h.join().unwrap(); }
    println!("Counter: {}", *counter.lock().unwrap());  // 10
}