use std::io; // Bring the `io` module into scope
use std::collections::HashMap; // Bring a specific struct into scope

fn main() {
    println!("Hello, Rust!");
    let mut map = HashMap::new();
    map.insert("key", "value");
    println!("{:?}", map);
}

fn main() {
    let x = 5; // Immutable variable
    println!("The value of x is: {}", x);

    let mut y = 10; // Mutable variable
    println!("The value of y is: {}", y);
    y = 15;
    println!("The new value of y is: {}", y);

    const MAX_POINTS: u32 = 100_000; // Constants (must be annotated)
    println!("Max points: {}", MAX_POINTS);
}

fn main() {
    let x = 5;
    let x = x + 1; // x is shadowed by a new x
    let x = x * 2;
    println!("The value of x is: {}", x); // Output: 12
}

use std::io;

fn main() {
    println!("Hello, Rust!");
    println!("Please enter your name:");

    let mut name = String::new(); // Create a mutable, empty String
    io::stdin()
        .read_line(&mut name) // Read line into `name`
        .expect("Failed to read line");

    let name = name.trim(); // Shadow `name` with a trimmed version

    println!("Hello, {}!", name);
}

fn main() {
    let number = 7;
    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }

    // `if` is an expression
    let condition = true;
    let num = if condition { 5 } else { 6 };
    println!("The value of num is: {}", num);
}

fn main() {
    let coin = Coin::Quarter;
    match coin {
        Coin::Penny => println!("Lucky penny!"),
        Coin::Nickel => println!("Five cents!"),
        Coin::Dime => println!("Ten cents!"),
        Coin::Quarter => println!("Twenty-five cents!"),
    }

    // Match with enum that holds data
    let msg = Message::Write(String::from("hello"));
    match msg {
        Message::Quit => println!("The Quit variant has no data."),
        Message::Move { x, y } => println!("Move to ({}, {})", x, y),
        Message::Write(text) => println!("Text message: {}", text),
        Message::ChangeColor(r, g, b) => println!("Change color to ({}, {}, {})", r, g, b),
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    // `loop` loop (infinite loop, can return a value)
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("The result is {}", result); // Output: 20

    // `while` loop
    let mut number = 3;
    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }
    println!("LIFTOFF!!!");

    // `for` loop (iterating over collections)
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("the value is: {}", element);
    }

    // For loop with range
    for number in (1..4).rev() { // 3, 2, 1
        println!("{}!", number);
    }
}

fn main() {
    another_function(5, 6);
    let x = five();
    println!("The value of x is: {}", x);
    let y = plus_one(5);
    println!("The value of y is: {}", y);
}

fn another_function(x: i32, y: i32) {
    println!("The value of x is: {}", x);
    println!("The value of y is: {}", y);
}

fn five() -> i32 {
    5 // This is an expression, not a statement (no semicolon)
}

fn plus_one(x: i32) -> i32 {
    x + 1 // This is an expression, not a statement
}

fn main() {
    let s1 = String::from("hello"); // s1 owns "hello"
    let s2 = s1; // s1 is moved to s2; s1 is no longer valid
    // println!("{}", s1); // Compile-time error: borrow of moved value: `s1`

    let s3 = s2.clone(); // Deep copy, s2 and s3 are separate owners
    println!("s2: {}, s3: {}", s2, s3);

    takes_ownership(s2); // s2's value moves into the function, s2 is no longer valid
    // println!("{}", s2); // Compile-time error

    let x = 5; // Integers implement `Copy` trait, so they are copied
    let y = x;
    println!("x: {}, y: {}", x, y); // Both x and y are valid

    makes_copy(x); // x's value is copied into the function
    println!("x: {}", x); // x is still valid
}

fn takes_ownership(some_string: String) { // some_string comes into scope
    println!("{}", some_string);
} // some_string goes out of scope and `drop` is called. Memory is freed.

fn makes_copy(some_integer: i32) { // some_integer comes into scope
    println!("{}", some_integer);
} // some_integer goes out of scope. Nothing special happens.

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // Pass a reference to s1
    println!("The length of '{}' is {}.", s1, len); // s1 is still valid

    let mut s = String::from("hello");
    change(&mut s); // Pass a mutable reference
    println!("Modified string: {}", s);
}

fn calculate_length(s: &String) -> usize { // s is a reference to a String
    s.len()
} // s goes out of scope. Nothing is dropped.

fn change(some_string: &mut String) { // some_string is a mutable reference
    some_string.push_str(", world");
}

fn main() {
    let mut s = String::from("hello");

    let r1 = &s; // Immutable reference
    let r2 = &s; // Another immutable reference
    println!("{}, {}", r1, r2);
    // r1 and r2 go out of scope here, so we can create a mutable reference below

    let r3 = &mut s; // One mutable reference
    r3.push_str(" world");
    println!("{}", r3);

    // This would be a compile-time error:
    // let r4 = &s; // Cannot have immutable reference while mutable reference (r3) is active
    // println!("{}", r4);
}

fn main() {
    let s = String::from("hello world");

    let hello = &s[0..5]; // Slice from index 0 to 5 (exclusive)
    let world = &s[6..11]; // Slice from index 6 to 11 (exclusive)

    println!("{} {}", hello, world);

    let full_slice = &s[..]; // Slice of the entire string
    println!("{}", full_slice);

    let mut a = [1, 2, 3, 4, 5];
    let slice = &mut a[1..4]; // Mutable slice of an array
    slice[0] = 99;
    println!("{:?}", a); // Output: [1, 99, 3, 4, 5]
}

fn main() {
    let mut v: Vec<i32> = Vec::new(); // Create an empty vector
    v.push(5);
    v.push(6);
    v.push(7);
    println!("{:?}", v); // Output: [5, 6, 7]

    let v2 = vec![1, 2, 3]; // Macro for creating a vector with initial values
    println!("{:?}", v2);

    let third: &i32 = &v[2]; // Access element by index
    println!("The third element is {}", third);

    // Iterating
    for i in &mut v {
        *i += 50; // Dereference to modify value
    }
    println!("{:?}", v);
}

fn main() {
    let mut s = String::new(); // Empty mutable String
    s.push_str("hello"); // Append a string slice
    s.push(' '); // Append a character
    s.push_str("world");
    println!("{}", s); // Output: hello world

    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");
    let s = format!("{}-{}-{}", s1, s2, s3); // Efficient concatenation
    println!("{}", s);

    let hello = "Здравствуйте"; // String literal (&str)
    for c in hello.chars() { // Iterate over Unicode characters
        print!("{} ", c);
    }
    println!();
}

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);
    println!("{:?}", scores);

    let team_name = String::from("Blue");
    let score = scores.get(&team_name); // Get a reference to the value
    println!("Blue team score: {:?}", score);

    // Iterate over map
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }

    // Insert only if key not present
    scores.entry(String::from("Blue")).or_insert(25);
    scores.entry(String::from("Green")).or_insert(25);
    println!("{:?}", scores);
}

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };
    println!("User: {} ({})", user1.username, user1.email);

    let mut user2 = User {
        email: String::from("another@example.com"),
        username: String::from("anotherusername567"),
        active: true,
        sign_in_count: 1,
    };
    user2.email = String::from("newemail@example.com"); // Mutate field
    println!("User 2 new email: {}", user2.email);

    // Struct Update Syntax
    let user3 = User {
        email: String::from("third@example.com"),
        ..user2 // Take remaining fields from user2 (moves non-Copy types)
    };
    // println!("{}", user2.username); // Error: user2.username moved to user3
    println!("User 3 username: {}", user3.username);
}

enum IpAddrKind {
    V4,
    V6,
}

enum IpAddr { // Enum with data
    V4(u8, u8, u8, u8),
    V6(String),
}

enum Message { // More complex enum variants
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    let home = IpAddr::V4(127, 0, 0, 1);
    let loopback = IpAddr::V6(String::from("::1"));

    let msg = Message::Write(String::from("hello"));
    // Use match to handle enum variants (see Control Flow section for example)
}

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| { // Closure runs in new thread
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap(); // Wait for the spawned thread to finish
    println!("Main thread finished.");
}

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel(); // Create a new channel: (transmitter, receiver)

    thread::spawn(move || { // Move tx into the spawned thread
        let val = String::from("hi");
        tx.send(val).unwrap(); // Send value through the channel
        // println!("val is {}", val); // Error: val moved to tx.send()
    });

    let received = rx.recv().unwrap(); // Block until a value is received
    println!("Got: {}", received);

    // Multiple messages
    let (tx2, rx2) = mpsc::channel();
    let tx3 = mpsc::Sender::clone(&tx2); // Clone transmitter for multiple producers

    thread::spawn(move || {
        let msgs = vec![
            String::from("more"),
            String::from("messages"),
            String::from("for"),
            String::from("you"),
        ];
        for msg in msgs {
            tx2.send(msg).unwrap();
            thread::sleep(Duration::from_millis(100));
        }
    });

    thread::spawn(move || {
        let msgs = vec![
            String::from("and"),
            String::from("even"),
            String::from("more"),
            String::from("messages"),
        ];
        for msg in msgs {
            tx3.send(msg).unwrap();
            thread::sleep(Duration::from_millis(50));
        }
    });

    for received in rx2 { // rx2 acts as an iterator
        println!("Got: {}", received);
    }
}

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

fn main() {
    // Arc enables multiple ownership over shared data
    // Mutex provides mutual exclusion for safe mutable access
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter); // Clone Arc for each thread
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap(); // Acquire lock, blocks if already locked
            *num += 1; // Mutate the protected data
            // Lock is automatically released when `num` goes out of scope
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap()); // Final count should be 10
}

pub trait Summary {
    fn summarize(&self) -> String; // Required method
    
    // Default implementation (optional)
    fn summarize_author(&self) -> String {
        String::from("(Read more...)")
    }
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

fn main() {
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from("of course, as you probably already know, people"),
        reply: false,
        retweet: false,
    };
    println!("Tweet summary: {}", tweet.summarize());

    let article = NewsArticle {
        headline: String::from("Penguins win the Stanley Cup!"),
        location: String::from("Pittsburgh, PA"),
        author: String::from("Iceburgh"),
        content: String::from("The Pittsburgh Penguins once again won the Stanley Cup."),
    };
    println!("Article summary: {}", article.summarize());
    println!("Article author summary: {}", article.summarize_author()); // Using default implementation
}

// Trait as a parameter (Trait Bound Syntax)
pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

// Trait as a parameter (impl Trait syntax - syntactic sugar for trait bounds)
pub fn notify_sugar(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

// Trait as a return type (only if returning single concrete type)
// pub fn returns_summarizable() -> impl Summary {
//     Tweet { /* ... */ }
// }

pub trait Draw {
    fn draw(&self);
}

pub struct Screen {
    pub components: Vec<Box<dyn Draw>>, // Vector of trait objects
}

impl Screen {
    pub fn run(&self) {
        for component in self.components.iter() {
            component.draw();
        }
    }
}

pub struct Button {
    pub width: u32,
    pub height: u32,
    pub label: String,
}

impl Draw for Button {
    fn draw(&self) {
        println!("Drawing a Button ({}x{}) with label: {}", self.width, self.height, self.label);
    }
}

pub struct SelectBox {
    pub width: u32,
    pub height: u32,
    pub options: Vec<String>,
}

impl Draw for SelectBox {
    fn draw(&self) {
        println!("Drawing a SelectBox ({}x{}) with options: {:?}", self.width, self.height, self.options);
    }
}

fn main() {
    let screen = Screen {
        components: vec![
            Box::new(SelectBox {
                width: 75,
                height: 10,
                options: vec![
                    String::from("Yes"),
                    String::from("Maybe"),
                    String::from("No"),
                ],
            }),
            Box::new(Button {
                width: 50,
                height: 20,
                label: String::from("OK"),
            }),
        ],
    };

    screen.run();
}

fn main() {
    // panic!("crash and burn"); // This will cause the program to crash

    let v = vec![1, 2, 3];
    // v[99]; // This would panic at runtime if not caught by bounds checks
}

fn main() {
    let some_number = Some(5);
    let some_string = Some("a string");
    let absent_number: Option<i32> = None;

    // Using `match` with Option
    let x = 5;
    let y: Option<i32> = Some(5);

    match y {
        Some(i) => println!("Value is: {}", i),
        None => println!("No value"),
    }

    // Using `if let` for concise matching
    if let Some(value) = some_number {
        println!("The value is: {}", value);
    } else {
        println!("No value present.");
    }

    // `unwrap()` and `expect()` (use with caution, can panic!)
    let value = some_number.unwrap(); // Panics if None
    let value = some_string.expect("String should be present"); // Panics with custom message if None
}

use std::fs::File;
use std::io::ErrorKind; // For specific error kinds

fn main() {
    let f = File::open("hello.txt"); // Returns a Result<File, io::Error>

    let f = match f {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {:?}", e),
            },
            other_error => panic!("Problem opening the file: {:?}", other_error),
        },
    };
    println!("File opened/created successfully: {:?}", f);

    // Using `unwrap()` and `expect()` with Result (use with caution!)
    // let f = File::open("another.txt").unwrap(); // Panics on Err
    // let f = File::open("another.txt").expect("Failed to open another.txt"); // Panics with custom message on Err

    // Using `?` operator for propagating errors
    // (Can only be used in functions that return Result)
    // fn read_username_from_file() -> Result<String, io::Error> {
    //     let mut f = File::open("username.txt")?; // Propagates error if any
    //     let mut s = String::new();
    //     f.read_to_string(&mut s)?; // Propagates error if any
    //     Ok(s)
    // }
}

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {}", result);

    let string3 = String::from("long string is long");
    {
        let string4 = String::from("xyz");
        let result = longest(string3.as_str(), string4.as_str());
        println!("The longest string is {}", result);
    }
}

// Function signature with lifetime annotations
// 'a indicates that the returned reference will live as long as the shortest of the two input references.
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

struct ImportantExcerpt<'a> {
    part: &'a str, // This struct holds a reference with lifetime 'a
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let i = ImportantExcerpt { part: first_sentence };
    println!("Excerpt: {}", i.part);
}

// src/main.rs
mod front_of_house { // Define a module
    pub mod hosting { // Public submodule
        pub fn add_to_waitlist() { // Public function
            println!("Added to waitlist!");
        }
    }
    mod serving { // Private submodule
        fn take_order() {}
    }
}

fn main() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();

    // Using `use` to bring into scope
    use crate::front_of_house::hosting;
    hosting::add_to_waitlist();
}

# Cargo.toml
[package]
name = "my_project"
version = "0.1.0"
edition = "2021"

[dependencies]
rand = "0.8.5" # Example dependency

use rand::Rng; // Use a function from the 'rand' crate

fn main() {
    let secret_number = rand::thread_rng().gen_range(1..101);
    println!("Secret number: {}", secret_number);
}

// src/lib.rs (or src/main.rs for unit tests)
pub fn add_two(a: i32) -> i32 {
    a + 2
}

#[cfg(test)] // Only compile when running tests
mod tests {
    use super::*; // Bring outer items into scope

    #[test] // Marks a function as a test
    fn it_works() {
        assert_eq!(4, add_two(2)); // Assertion macro
    }

    #[test]
    #[should_panic(expected = "less than or equal to 100")] // Expect a panic with specific message
    fn another_test() {
        // This test will pass if the code inside panics with the expected message
        panic_if_too_high(101);
    }

    fn panic_if_too_high(x: i32) {
        if x > 100 {
            panic!("Value {} is too high, must be less than or equal to 100", x);
        }
    }

    #[test]
    #[ignore = "reason for ignoring"] // Ignores this test by default
    fn expensive_test() {
        // This test won't run with `cargo test`
        // Run with `cargo test -- --ignored`
    }
}

// To run tests:
// cargo test
// cargo test -- --show-output // Show println! output from tests
// cargo test it_works // Run specific test
// cargo test -- --test-threads=1 // Run tests sequentially

struct CustomSmartPointer {
    data: String,
}

// Implement the Drop trait for CustomSmartPointer
impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("my stuff"),
    };
    let d = CustomSmartPointer {
        data: String::from("other stuff"),
    };
    println!("CustomSmartPointers created.");
    // 'c' and 'd' will be dropped when they go out of scope,
    // calling their `drop` implementations automatically.

    // You cannot explicitly call `drop()` directly to clean up:
    // c.drop(); // Compile-time error: explicit use of destructor method
    // Use `std::mem::drop` if you need to force an early drop:
    // std::mem::drop(c);
    // println!("CustomSmartPointer c dropped before the end of main.");
}