// every rust program starts with a "main" function
fn main() {
    // indentation doesn't (syntactically) matter, convention is 4 spaces
    // ""->string literals
    println!("Hello world"); // ! (shebang) means println! is a macro instead of a normal function
}

// from the rust standard library
// std::io is not included in prelude, so we have to import it explicitely
use std::io;
// The Rng trait defines methods that random number generators implement,
use rand::Rng;
use std::cmp::Ordering;

fn main() {
    println!("Guess the number");

    // 1..=100 is an inclusive range expression
    let secret_number = rand::thread_rng().gen_range(1..=100); // random number 1-100 (inclusive)

    loop {
        println!("Please input your guess");
        // variables are declared using "let".
        // variables are immutable by default; to declare them as mutable, we add "mut"
        // ::new is an associated function implemented on the type String
        let mut guess = String::new(); // growable, UTF-8 encoded string

        // id we didn't import std::io, we could still use the function by
        // writing std::io::stdin
        io::stdin() // returns an instance of std::io::Stding type which represents a handle to stdin
            // pass in reference (&) to read_line and indicate its mutability with mut
            // read_lone returns a Result enum, a type that can be in one of multiple possible states ("variants")
            .read_line(&mut guess) // possible variants: Ok and Err
            // Values of the Result type have methods defined such as expect
            .expect("Failed to read line"); // Crash if result is Err
        // without expect, there would be a warning during compilation

        // convert guess to string for later comparison
        // the existing guess variable is shadowed so we can use the same name
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        // {} is a placeholder, similar to javascripts `you guessed: ${guess}`
        // We could have written println!("you guessed: {}", guess)
        println!("you guessed: {guess}, which was:");

        // match constructs ensure all cases / "arms" are handled
        match guess.cmp(&secret_number) { // cmp returns one of the arms patterns, e.g. Ordering:Less
            Ordering::Less => println!("too low"),       // "arms" of the match expression
            Ordering::Greater => println!("too high"),   // an arm consists of a pattern to match against
            Ordering::Equal => {
                println!("correct");
                break; // end the loop
            },       // and the code to run if it matches
        }

    }
}

fn main() {
  let x = 1;
  println!("{x}"); // 1 - just so the compiler doesn't complain that x isn't used
  let x = "wowser";
  {
    let x = 55;
    println!("{x}") // 55
  }
  println!("{x}") // wowser
}

fn main() {
  let tup: (i32, f64, u8) = (500, 6.4, 1);
  let second_value = tup.1; // 6.4
  let (x, y, z) = tup; // destructuring like in javascript except () instead of {}
}

fn main() {
  let a = [1, 2, 3, 4, 5];
  let b: [i32; 5] = [1, 2, 3, 4, 5]; // explicitly state type and length
  let c = [3; 5]; // creates an array of length 5 with all values being 3 ([3, 3, 3, 3, 3])
  
  let a_second = a[1]; 
}

fn five() -> int32 {
  5 // ok, last expression in the code block
}

fn six() -> int32 {
  6; // error - 6 is a statement because of the ;
}

fn seven() -> int32 {
  return 7; // ok
}

// idiomatic 
// multiline comment

fn main() {
    let mut x = 0;
    loop {
        x = x + 1;
        println!("i run 10 times{x}");
        if x == 10 {
            break;
        }
    }

    x = 0;
    let y = loop {
        x+=1;

        if x > 20 {
            break x;
        }
    }; // if used as an expression, ";" is necessary

    println!("twentyone is {y}");

    x = 0;
    let z = 'outer_loop: loop {
        'inner_loop: loop {

            if x >= 5 {
                break 'inner_loop;
            }
            x = x + 1;
            println!("I print 5 times");
        }
        x = x + 1;
        if x > 15 {
            break 'outer_loop x; // just add return (if required) after the label
        }
        println!("And I print 10 times");
    };

    x = 0;
    while x < 10 {
        println!("Me too!");
        x+=1;
    }

    for el in [1,2,3,4,5] {
        println!("{el}"); // 1,2,3,4,5
    }

    // just to show how a range can be defined
    for el in (1..5).rev() { // tuple (5,4,3,2,1)
      println!("{el}");
    }

    loop {
        println!("I am an endless loop! Please kill me!");
    }
}

fn main() {
    //simple datatypes on the stack
    {
        // side note: prefixing a variable with "_" lets the compiler know it's intentionally unused
        let _s = "hello"; // primitive str type, size know at compile time, hardcoded into executable
    } // s goes out of scope
    //println!("{}", s); // can't find value s in this scope

    {
        // complex string type
        // unknown size at compile time
        let mut s = String::from("hello"); // heap memory is requested from the allocator
        s.push_str(", world!");
        println!("{}", s);
    } // scope is over, s is no longer valid; memory is automatically returned
}

fn main() {
    let x = 5;
    let y = x; // primitive type - value is copied on the stack

    let s1 = String::from("hello");
    // a new String object is created on the stack that points to the same memory location as s1
    // basically like a reference in javascript
    let s2 = s1; // in rust speak: s1 is moved to s2
    // from here, s1 is no longer valid and accessing it will lead to compile errors
    // this is done by rust so the allocator doesn't try to free memory twice
    // when both s1 and s2 go out of scope
    // println!("{s1}"); // compiler error
    println!("{s2}"); // fine

    let s3 = s2.clone(); // explicit deep copy, s2 stays valid
    println!("{s3}, {s2}"); // hello, hello

    print_me(s2);
    print_me(s2); // error! print_me took ownership so s2 is no longer valid!
}

fn print_me(s: String) {
  println!("{s}");
}

fn main() {
    let s = String::from("hello");  // s comes into scope

    takes_ownership(s);             // s's value moves into the function...
                                    // ... and so is no longer valid here
                                    // AND THIS IS THE SURPRISING PART

    let x = 5;                      // x comes into scope

    makes_copy(x);                  // x would move into the function,
                                    // but i32 is Copy, so it's okay to still
                                    // use x afterward

} // Here, x goes out of scope, then s. But because s's value was moved, nothing
  // special happens.

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

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

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

    let (s2, len) = calculate_length(s1);

    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); // len() returns the length of a String

    (s, length)
}

fn main() {
    print_me(&s2);
    print_me(&s2); // no more error as we pass it by reference (see function signature with &)
}

fn print_me(s: &String) {
    s.push_str("this will not work"); // variables passed by reference can't be modified
    println!("{s}");
} // s goes out of scope, but it's just a reference to s2, so s2 is still fine

let mut s = String::from("hello");
let r = &s;     // Immutable borrow of `s`
// let r_mut = &mut s; // This line would cause a compile error

println!("s is {}", s); // OK: `s` can be accessed while it's immutably borrowed
// r_mut.push_str(", world"); // Error: cannot borrow `s` as mutable because it is also borrowed as immutable

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

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

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

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    let thisWillError = &mut s; // PROBLEM: an object with a mutable variable can't have any other references attached to it
    println!("{} and {}", r1, r2);
    // variables r1 and r2 will not be used after this point

    let r3 = &mut s; // no problem, as r1 and r2 are not used anymore in the program / scope
    println!("{}", r3);
}

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s  // we (try to) return a reference to the string s
}       // but s goes out of scope here so it (it's memory) ceases to exist,
        // so the returned pointer would point to nothing

fn no_dangle() -> String {
    let s = String::from("hello");

    s // fine, whole string is returned (ownership is moved to calling scope)
}

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

    // create slices of the string
    let hello = &s[0..5]; // [firstPos..LastPosExclusive]
    let world = &s[6..11];

    println!("{}", &s[0..4]); // hell
    println!("{}", &s[6..]); // world
    println!("{}", &s[..]); // hello world
}

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

    let res = first_word(&s);

    println!("{res}");
}

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

let a = [1, 2, 3, 4, 5];
let slice = &a[1..3];
assert_eq!(slice, &[2, 3]);

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

fn main() {
  let mut user1 = User { // no "new" keyword to instantiate a value from a struct type
    sign_in_count: 1, // order is irrelevant
    active: true,
    username: String::from("abc"), // we want to change these later maybe,
    email: String::from("a@bc.de"), // so we don't use a str (which would be inlined at compile time)
  };

  // we can only re-assign if the whole struct instance is instantiated with "mut";
  // we can't set individual fields in a struct to "mut"
  user1.email = String::from("ab@c.de");

  // creating a User from another User
  let user2 = User {
    active: user1.active, // this is a primitive value that implements the copy trait so it's COPIED from user1
    username: user1.username,   // these are String value (complex object/value), so they are
    email: user1.email,         // MOVED to user2 and thus are NOT AVAILABLE IN user1 ANYMORE!
    sign_in_count: user1.sign_in_count
  };

  // shorthand for assigning from another User
  let user3 = User {
    email: String::from("another@example.com"),
    ..user2 // again, non-primitive values are MOVED to user3 so user2 isn't complete anymore
  };
}

// User is a type we can use as parameter or return types as well
fn build_user(email: String, username: String) -> User {
  User {
    active: true,
    username,   // we can use shorthand notation like in javascript if a variable
    email,      // with the same name exists in the current scope (here from the parameters)
    sign_in_count: 1,
  }
}

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

struct AlwaysEqual;

fn main() {
  let subject = AlwaysEqual;
}

struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    // println!("rect1 is {}", rect1); // compile error because Rectangle doesn't have a Display trait,
                                    // meaning it doesn't know how to show itself as a string
                                    // similar to .toString() (js) or __rep__ (python)

    // println!("rect1 is {:?}", rect1);   // we say "use Debug trait as the string conversion method
                                        // doesn't exist either on our Rectangle struct
                                        // so it still errors



    #[derive(Debug)] // attribute to let rust add a debug trait to the struct
    struct RectangleWithDbg {
        width: u32,
        height: u32,
    }

    // structs can be defined in another scope, too
    let rect2 = RectangleWithDbg {
        width: 30,
        height: 50,
    };

    println!("rect1 is {:?}", rect2); // output: rect1 is RectangleWithDbg { width: 30, height: 50 }
    
    println!("rect1 is {:#?}", rect2); // note the #; multiline output;
    // output: 
    // rect1 is RectangleWithDbg {
    //     width: 30,
    //     height: 50,
    // }
}

let rect3 = dbg!(rect2); // assigns and logs value to stdout using Debug trait

use std::cmp::min;

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

// methods are defined outside of the struct using impl
// (implementation block)
impl Rectangle {
    // like in python, self must be the first parameter if we want
    // to access the struct instance data
    // &self is shorthand for self: &Self
    // we use &self (immutable reference) because we don't want to take ownership / change anything
    fn area(&self) -> u32 {
        self.height * self.width
    }

    // make self mutatable and add a parameter
    fn add_height(&mut self, units: u32) {
        self.height += 10;
    }

    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }

    // very rarely used, takes ownership of self
    // usually used when the method transforms self into something else and you want to prevent the caller from using the original instance after the transformation
    fn convert_to_string(self) -> String {
        format!("{}, {}", self.height, self.width)
    }

    // associated functions that are not methods
    // basically static methods called with Type::function, e.g. String::from
    // these are distinguished by not having a self parameter
    fn square(side_length: u32) -> Self {    // returns an instance of the type it's called on;
                                            // -> Rectangle would be ok as well
        Self {
            width: side_length,
            height: side_length
        }
    }
}

// there can be multiple impl blocks for the same type
impl Rectangle {
    fn whatever(&self) {
        ()
    }

}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("{}", rect1.area()); // 1500

    let mut rect2 = Rectangle {
        width: 30,
        height: 50,
    };

    rect2.add_height(10);
    println!("{}", rect2.area()); // 1600

    let rectString = rect2.convert_to_string();
    // rect2.width; // compiler error - rect2 was taken ownership of and is no longer available
    println!("{}", rectString); // 60, 30

    let square = Rectangle::square(10);
    println!("{}", square.area()); // 100
}

// basic enum
enum IpAddrKind { // CamelCase for enums
    V4, // these are not existing types but enum variants
    V6, // that can be used as-is
}

// used as a param / type
fn route(ip_kind: IpAddrKind) {}

fn main() {
    // create instances of enum
    let four = IpAddrKind::V4;
    route(four);
    // use directly
    route(IpAddrKind::V6);
}

// enum with types in variants
// the types of the variants can be anything: tuples, structs etc.
enum IpAddrKind {
    V4(u8, u8,u8,u8), // V4 is a tuple of 4 u8s
    V6(String)
}

// enums can have methods, too
impl IpAddrKind {
    fn show(&self) {
        // this is how we can access the variant of the current instance
        match self {
            IpAddrKind::V4(a, b, c, d) => println!("{}.{}.{}.{}", a, b, c, d), // destructure data
            IpAddrKind::V6(s) => println!("{}", s),
        }
    }
}
// used as a param / type
// note that here route takes ownership, so it vanishes from the calling scope after call
fn route(ip_kind: IpAddrKind) {}

fn main() {
    // create instances of enum
    let four = IpAddrKind::V4(127,0,0,1);
    route(four);
    // use directly
    route(IpAddrKind::V6(String::from("::1")));

    (IpAddrKind::V4(127,0,0,1)).show(); // 127.0.0.1
}

enum Option<T> {
    None,
    Some(T),
}

fn main() {
    let some_number = Some(5); // type is Option<i32>
    let some_char = Some('e'); // type is Option<char>

    let absent_number: Option<i32> = None; // basically null

    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    //let i_error= x + y; // error

    // we MUST explicitely handle the possible None value
    let sum = match y {
        Some(num) => x + num,  // If y is Some(i8), add it to x
        None => x,            // If y is None, just use x
    };

    println!("{sum}"); // 10
}

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState) // an enum with a value, here it's another enum
}

fn main() {
    let a_penny = Coin::Penny;
    let a_quarter = Coin::Quarter(UsState::Alaska);

    println!("{}", value_in_cents(&a_penny));   // 1
    println!("{}", value_in_cents(&a_quarter)); // 25 (and prints "Quarter from Alaska")

}

fn value_in_cents(coin: &Coin) -> u8 {
    match coin {
        Coin::Penny => 1,    // arms of the match expression
        Coin::Nickel => 5,   // return 1 if coin is a penny
        Coin::Dime => 10,
        Coin::Quarter(state) =>  { // we can use blocks, too
            println!("Quarter from {:?}", state); // side effect
            25                          // return 25
        }
    }
}

fn main() {
    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);

}

fn plus_one(x: Option<i32>) -> Option<i32> {
    // None and Some(x) are from the standard library 
    // and are included in the prelude
    // They return an Option value
    match x {
        None => None,               // without this line, there'd be an error as not all cases are covered
        Some(i) => Some(i+1)    // access the Some value
    }
}

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        // all other values ("other", an arbitrary variable name, binds to the value)
        // other is bound to the actual value
        other => move_player(other),
    }

    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        // _ matches any value but doesn't bind to the value
        // used to indicate to the compiler that the value will not be used
        _ => shrug_at_player(),
        // if we really don't do anything, we could also return a unit
        // _ => ()
        // or
        // _ => {}
    }

}

fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn shrug_at_player() {}
fn move_player(num_spaces: u8) {}

fn random_number(value: &i32) -> u32 {
    5
}

fn main() {
    let secret_number = 42; // Example value

    match random_number(&secret_number) {
        4 => println!("Success!"),
        6 => println!("Failure!"),
        _ => {} // since rust can't determine random_number, it insists on a catch_all
    }
}

fn main() {
    let config_max = Some(3u8); // numeric literal with type prefix
    // using match
    match config_max {
        Some(max) => println!("The maximum is configured to be {}", max),
        _ => (),
    }

    // Using if let
    if let Some(max) = config_max { // this is basically assigning config_max to max
        println!("The maximum is configured to be {}", max);
    } else {
        println!("Max connections are not configured");
    }
}