// How Option is defined in the standard library
enum Option<T> {
    Some(T), // a value of type T is present
    None,    // no value
}

// Both variants are available without any import
fn main() {
    let present: Option<i32> = Some(42);
    let absent:  Option<i32> = None;

    println!("{:?}", present); // Some(42)
    println!("{:?}", absent);  // None
}

fn main() {
    // Explicit construction
    let name: Option<String> = Some(String::from("Alice"));
    let no_name: Option<String> = None;

    // Vec::get returns Option — index may be out of bounds
    let v = vec![10, 20, 30];
    let first   = v.get(0);  // Some(&10)
    let missing = v.get(99); // None

    println!("{:?}", first);   // Some(10)
    println!("{:?}", missing); // None

    // str::find returns Option<usize>
    let haystack = "hello world";
    let pos = haystack.find("world"); // Some(6)
    let nope = haystack.find("xyz");  // None
    println!("{:?}", pos);  // Some(6)
    println!("{:?}", nope); // None

    // Parsing returns Result, but you can convert to Option
    let good: Option<i32> = "42".parse().ok();  // Some(42)
    let bad:  Option<i32> = "abc".parse().ok(); // None
    println!("{:?} {:?}", good, bad);
}

fn double(n: i32) -> i32 {
    n * 2
}

fn main() {
    let value: Option<i32> = Some(5);

    // ERROR: cannot pass Option<i32> to a function expecting i32
    // let result = double(value); // compile error!

    // You must handle both cases:
    let result = match value {
        Some(n) => double(n),
        None    => 0, // chose a sensible default
    };
    println!("{}", result); // 10
}

fn find_user(id: u32) -> Option<String> {
    match id {
        1 => Some(String::from("Alice")),
        2 => Some(String::from("Bob")),
        _ => None,
    }
}

fn greet(id: u32) {
    match find_user(id) {
        Some(name) => println!("Hello, {}!", name),
        None       => println!("User {} not found.", id),
    }
}

fn main() {
    greet(1); // Hello, Alice!
    greet(2); // Hello, Bob!
    greet(9); // User 9 not found.

    // Match with a guard for extra conditions
    let score: Option<u32> = Some(85);
    match score {
        Some(s) if s >= 90 => println!("Excellent: {}", s),
        Some(s) if s >= 70 => println!("Passing: {}", s),
        Some(s)            => println!("Failing: {}", s),
        None               => println!("No score recorded"),
    }
    // Passing: 85
}

fn main() {
    let config_value: Option<u32> = Some(8080);

    // Full match — more verbose when you only care about Some
    match config_value {
        Some(port) => println!("Listening on port {}", port),
        None       => {},
    }

    // if let — cleaner for single-branch matching
    if let Some(port) = config_value {
        println!("Listening on port {}", port);
    }

    // if let with an else branch
    if let Some(port) = config_value {
        println!("Custom port: {}", port);
    } else {
        println!("Using default port 80");
    }

    // Chaining with else if let for multiple options
    let raw: Option<&str> = Some("  hello  ");
    if let Some(s) = raw {
        if let Some(first) = s.trim().chars().next() {
            println!("First char: {}", first); // First char: h
        }
    }
}

fn main() {
    let x: Option<i32> = Some(7);
    let value = x.unwrap(); // 7 — OK because we know it's Some
    println!("{}", value);

    // This panics at runtime:
    // let y: Option<i32> = None;
    // let boom = y.unwrap(); // thread 'main' panicked at 'called `Option::unwrap()` on a `None` value'
}

// Common safe use: immediately after constructing a known-Some value
fn parse_port(s: &str) -> u16 {
    s.parse().ok().unwrap() // fine in tests where s is a known literal
}

fn load_config(key: &str) -> Option<String> {
    // Imagine reading from a config file
    if key == "host" { Some(String::from("localhost")) } else { None }
}

fn main() {
    // With a descriptive message, the panic tells you exactly what went wrong
    let host = load_config("host")
        .expect("config key 'host' must be set");
    println!("{}", host); // localhost

    // This would panic with a clear message:
    // let timeout = load_config("timeout")
    //     .expect("config key 'timeout' must be set");
    // thread 'main' panicked at "config key 'timeout' must be set"
}

fn main() {
    let user_setting: Option<u32> = None;
    let font_size = user_setting.unwrap_or(14);
    println!("font size: {}", font_size); // font size: 14

    let explicit_setting: Option<u32> = Some(20);
    let font_size2 = explicit_setting.unwrap_or(14);
    println!("font size: {}", font_size2); // font size: 20

    // Works with any type
    let name: Option<String> = None;
    let display = name.unwrap_or(String::from("Anonymous"));
    println!("{}", display); // Anonymous

    // unwrap_or_default uses the Default trait implementation
    let count: Option<i32> = None;
    println!("{}", count.unwrap_or_default()); // 0  (i32::default() == 0)

    let text: Option<String> = None;
    println!("{:?}", text.unwrap_or_default()); // ""  (String::default() == "")
}

fn expensive_default() -> String {
    println!("(computing default...)");
    String::from("computed-default")
}

fn main() {
    // The closure is NOT called because the option is Some
    let result: Option<String> = Some(String::from("cached"));
    let value = result.unwrap_or_else(|| expensive_default());
    println!("{}", value); // cached  (no "(computing default...)" printed)

    // The closure IS called because the option is None
    let missing: Option<String> = None;
    let value2 = missing.unwrap_or_else(|| expensive_default());
    // (computing default...)
    println!("{}", value2); // computed-default

    // Practical example: fall back to an environment variable
    let port: Option<u16> = None;
    let p = port.unwrap_or_else(|| {
        std::env::var("PORT")
            .ok()
            .and_then(|s| s.parse().ok())
            .unwrap_or(8080)
    });
    println!("port: {}", p); // port: 8080
}

// Without ?: nested if let chains
fn first_word_length_verbose(text: Option<&str>) -> Option<usize> {
    if let Some(t) = text {
        if let Some(word) = t.split_whitespace().next() {
            return Some(word.len());
        }
    }
    None
}

// With ?: clean and flat
fn first_word_length(text: Option<&str>) -> Option<usize> {
    let t    = text?;                          // return None if text is None
    let word = t.split_whitespace().next()?;   // return None if no words
    Some(word.len())
}

fn main() {
    println!("{:?}", first_word_length(Some("hello world"))); // Some(5)
    println!("{:?}", first_word_length(Some("")));            // None
    println!("{:?}", first_word_length(None));                // None
}

// ? in a method chain — extract user's city from nested structs
struct Address { city: Option<String> }
struct User    { address: Option<Address> }

fn user_city(u: &User) -> Option<&str> {
    u.address.as_ref()?.city.as_deref()
}

fn main2() {
    let user = User { address: Some(Address { city: Some(String::from("Berlin")) }) };
    println!("{:?}", user_city(&user)); // Some("Berlin")
}

fn main() {
    let length: Option<usize> = Some("hello").map(|s| s.len());
    println!("{:?}", length); // Some(5)

    let nothing: Option<usize> = None::<&str>.map(|s| s.len());
    println!("{:?}", nothing); // None

    // Chain map calls to transform step by step
    let result = Some("  42  ")
        .map(|s| s.trim())             // Some("42")
        .map(|s| s.parse::<i32>().ok()) // Some(Some(42))
        .flatten();                     // Some(42)
    println!("{:?}", result); // Some(42)

    // map vs and_then: use and_then when the function itself returns Option
    let parsed: Option<i32> = Some("99")
        .and_then(|s| s.parse().ok()); // and_then flattens automatically
    println!("{:?}", parsed); // Some(99)
}

fn parse_positive(s: &str) -> Option<i32> {
    s.parse::<i32>().ok()       // parse the string (Option<i32>)
     .filter(|&n| n > 0)        // keep only positive values
}

fn main() {
    // and_then: chain operations where each step might fail
    let result = Some("15")
        .and_then(|s| parse_positive(s));
    println!("{:?}", result); // Some(15)

    let negative = Some("-5")
        .and_then(|s| parse_positive(s));
    println!("{:?}", negative); // None  (filtered out)

    // filter: keep Some only when the predicate holds
    let even: Option<i32> = Some(4).filter(|&n| n % 2 == 0);
    println!("{:?}", even); // Some(4)

    let odd: Option<i32> = Some(3).filter(|&n| n % 2 == 0);
    println!("{:?}", odd); // None

    // or: return the first Some, falling through to a backup
    let primary:  Option<&str> = None;
    let secondary: Option<&str> = Some("backup-host");
    let host = primary.or(secondary);
    println!("{:?}", host); // Some("backup-host")

    // or_else: lazy version — closure only called when None
    let host2: Option<String> = None;
    let host3 = host2.or_else(|| Some(String::from("default-host")));
    println!("{:?}", host3); // Some("default-host")
}

fn main() {
    let value: Option<i32> = Some(5);
    let empty: Option<i32> = None;

    println!("{}", value.is_some()); // true
    println!("{}", value.is_none()); // false
    println!("{}", empty.is_some()); // false
    println!("{}", empty.is_none()); // true

    // Useful in conditionals without consuming the value
    let items: Vec<Option<i32>> = vec![Some(1), None, Some(3), None, Some(5)];
    let present_count = items.iter().filter(|opt| opt.is_some()).count();
    println!("present: {}", present_count); // present: 3
}

#[derive(Debug)]
enum AppError {
    UserNotFound(u32),
    InvalidInput(String),
}

fn find_user(id: u32) -> Option<String> {
    if id == 1 { Some(String::from("Alice")) } else { None }
}

fn get_user_name(id: u32) -> Result<String, AppError> {
    find_user(id).ok_or(AppError::UserNotFound(id))
}

fn main() {
    match get_user_name(1) {
        Ok(name) => println!("Found: {}", name),   // Found: Alice
        Err(e)   => println!("Error: {:?}", e),
    }

    match get_user_name(99) {
        Ok(name) => println!("Found: {}", name),
        Err(e)   => println!("Error: {:?}", e),    // Error: UserNotFound(99)
    }

    // ok_or_else: lazy — the error is only constructed when None
    let value: Option<i32> = None;
    let result: Result<i32, String> = value
        .ok_or_else(|| format!("value was missing at runtime"));
    println!("{:?}", result); // Err("value was missing at runtime")
}

#[derive(Debug)]
struct User {
    id:          u32,
    username:    String,
    email:       String,
    display_name: Option<String>,  // user may not have set a display name
    age:         Option<u8>,       // age is optional
    avatar_url:  Option<String>,
}

impl User {
    fn display(&self) -> &str {
        // Fall back to username when display_name is not set
        self.display_name.as_deref().unwrap_or(&self.username)
    }
}

fn main() {
    let alice = User {
        id:           1,
        username:     String::from("alice42"),
        email:        String::from("alice@example.com"),
        display_name: Some(String::from("Alice W.")),
        age:          Some(30),
        avatar_url:   None,
    };

    let bob = User {
        id:           2,
        username:     String::from("bob99"),
        email:        String::from("bob@example.com"),
        display_name: None,   // no display name set
        age:          None,
        avatar_url:   None,
    };

    println!("{}", alice.display()); // Alice W.
    println!("{}", bob.display());   // bob99  (falls back to username)

    if let Some(age) = alice.age {
        println!("{} is {} years old", alice.display(), age); // Alice W. is 30 years old
    }
}

fn main() {
    // map can produce Option<Option<T>> when the closure returns Option
    let text: Option<&str> = Some("42");
    let nested: Option<Option<i32>> = text.map(|s| s.parse().ok());
    println!("{:?}", nested); // Some(Some(42))

    // flatten collapses one nesting level
    let flat: Option<i32> = nested.flatten();
    println!("{:?}", flat); // Some(42)

    // and_then does map + flatten in one step
    let direct: Option<i32> = text.and_then(|s| s.parse().ok());
    println!("{:?}", direct); // Some(42)

    // None propagates correctly through flatten
    let bad: Option<Option<i32>> = Some(None);
    println!("{:?}", bad.flatten()); // None

    let outer_none: Option<Option<i32>> = None;
    println!("{:?}", outer_none.flatten()); // None
}