extern crate rand;

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
	// 첫 줄 출력
	println!("Guess the number!");

	// 1 부터 100까지의 숫자를 Rangdom으로 생성 후 secret_nmber로 선언
    let secret_number = rand::thread_rng().gen_range(1, 101);

    loop {
		// 질문 출력
        println!("Please input your guess.");

		// guess를 mutable 형태의 string으로 생성
        let mut guess = String::new();

		// guess의 입력을 받음
        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

		// guess를 trim하고 숫자로 전환
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

		// 사용자의 guess를 재출력
        println!("You guessed: {}", guess);

		// secret_number의 숫자를 비교하여 결과를 출력
        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

let foo = 5;	// immutable
let mut bar = 5;	// mutable
let baz = String::new();

io::stdin()
	.read_line(&mut guess)
	.expect("Failed to read line");

// place holder
println!("You guessed: {}", guess);
// place holder 지정
println!("You guessed: {g} number {n}", g= guess,n = number);

// Cargo.toml
[dependencies]
rand = "0.4.0"

match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
			}

let guess: u32 = match guess.trim().parse() {
	Ok(num) => num,
	Err(_) => continue,
};

loop {
...
match guess.cmp(&secret_number) {
		...
		Ordering::Equal => {
			println!("You win!");
			break;
		}
}

fn main() {
    // immutable
    let x = 5;
    println!("The value of x is: {}", x);
    // x = 7; // connot assign twice to immutable variable
    println!("The value of x is: {}", x);

    // shadowing
    let x = 10;
    println!("The value of x is: {}", x);

    // shadowing 2
    let spaces = "   ";
    println!("Spaces: {}", spaces);
    let spaces = spaces.len();
    println!("Spaces: {}", spaces);

    // mutable
    let mut x = 6;
    println!("The value of x is: {}", x);
    x = 7; // connot assign twice to immutable variable
    println!("The value of x is: {}", x);

    // mutable
    let mut spaces = "   ";
    println!("Spaces: {}", spaces);
    // spaces = spaces.len(); //expected `&str`, found `usize`
    println!("Spaces: {}", spaces);

    // const
    const MAX_POINTS: u32 = 100_000;
    println!("MAX_POINTS: {}", MAX_POINTS);

    // let guess = "42".parse().expect("Not a number!"); // consider giving `guess` a type
    let guess: u32 = "42".parse().expect("Not a number!");

    // float
    let f1: f64 = 2.0;
    let f2: f32 = 3.0;
    println!("{},{}", f1, f2);

    // let addition
    let sum = 5 + 10;
    // let subtraction
    let difference = 95.5 - 4.3;
    // let multiplication
    let product = 4 * 30;
    // let division
    let quotient = 56.7 / 32.2;
    // let remainder
    let remainder = 43 % 5;

    println!(
        "let calc {},{},{},{},{}",
        sum, difference, product, quotient, remainder
    );

    // boolean
    let t = true;
    let f: bool = false;

    println!("let bool {},{}", t, f);

    // character
    let c = 'z';
    let z = 'ℤ';
    let cat = '😻';

    println!("let char {},{},{}", c, z, cat);

    // tuple
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    let (x, y, z) = tup;
    println!("x : {}, y : {}, z : {}", x, y, z);

    let x: (i32, f64, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8) =
        (500, 6.4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
    let five_hundred = x.0;
    println!("five_hundred : {}, x11 : {}", five_hundred, x.11);

    // Array
    let ary = [1, 2, 3, 4, 5];
    let mon = [
        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
    ];

    let index = 4;
    // let index = 12; // panicked at 'index out of bounds: the len is 12 but the index is 12'

    let frst = ary[0];
    let scnd = mon[1];
    let thrd = mon[index];

    println!("frst : {} , scnd : {} , thrd : {}", frst, scnd, thrd);
}

fn main() {
    println!("Hello, world!");
    // function
    function_a();

    // function parameter
    function_b(3);

    // function parameters
    function_c(3, 5);

    // statement
    let stmt1 = 6;
    println!("stmt1 : {}", stmt1);
    // let stmt1 = (let stmt2 = 5); // variable declaration using `let` is a statement
    let stmt1 = 5;

    // expression
    let stmt2 = {
        let stmt1 = 3;
        stmt1 + 1
    };
    println!("stmt1 : {}, stmt2 : {}", stmt1, stmt2);

    // function with return values
    let stmt3 = function_d();
    println!("stmt3 : {}", stmt3);

    // function with return values
    let stmt4 = function_e(5);
    println!("stmt4 : {}", stmt4);
}

fn function_a() {
    println!("Hello, again!")
}

fn function_b(x: i32) {
    for i in 0..x {
        println!("{} : Hello, again!", i)
    }
}

fn function_c(x: i32, y: i32) {
    for i in x..y {
        println!("{}: Hello, again! {},{}", i, x, y)
    }
}

fn function_d() -> i32 {
    5
}

fn function_e(x: i32) -> i32 {
    // without semicolon
    x + 1
}

fn main() {
    // if else 1
    let number = 3;

    if number < 5 {
        println!("{} condition was true", number);
    } else {
        println!("{} condition was false", number);
    };

    // if else 2
    let number = 7;

    if number < 5 {
        println!("{} condition was true", number);
    } else {
        println!("{} condition was false", number);
    };

    // if else 3
    if number != 0 {
        println!("{} number was soething other than zero", number);
    };

    // if else 4
    if number % 4 == 0 {
        println!("{} number is divisible by 4", number)
    } else if number % 3 == 0 {
        println!("{} number is divisible by 3", number)
    } else if number % 2 == 0 {
        println!("{} number is divisible by 2", number)
    } else {
        println!("{} number is not divisible by 4,3,2", number)
    };

    // if with let
    let cond = true;
    let numb = if cond { 5 } else { 6 };

    println!("This value of numb is : {}", numb);

    // while
    let mut numc = 3;
    while numc != 0 {
        println!("{}", numc);
        numc = numc - 1;
    }
    println!("numc : {}", numc);

    // for collection
    let arry = [10, 20, 30, 40, 50];
    for elem in arry.iter() {
        println!("the value is: {}", elem);
    }

    // for range rev
    for numd in (1..4).rev() {
        println!("{}!", numd);
    }
}

fn main() {
    // move
    let str1 = String::from("hello");
    let str2 = str1; // shallow copy

    //println!("{}", str1); // move occurs because `str1` has type `std::string::String`
    println!("{}", str2);

    // function takes ownership
    let str3 = String::from("world");
    take_owns(str3);

    //println!("{}", str3); //value borrowed here after move

    // integer copy to function
    let intg = 5;
    make_copy(5);
    println!("{}", intg);

    //
    let str4 = String::from("again");
    let str5 = take_back(str4);

    //println!("{}", str4); //move occurs because `str4` has type `std::string::String`
    println!("{}", str5);

    // Reference
    let str6 = String::from("This is a pen");
    let leng = calc_leng(&str6);
    println!("The length of '{}' is {}", str6, leng);

    // Reference
    let mut str7 = String::from("This is a book");
    chng_strg(&mut str7);
    println!("{}", str7);

    // Reference mutable
    let mut str8 = String::from("text1");
    let str9 = &mut str8; //first mutable borrow occurs here
                          // let str10 = &mut str8; //second mutable borrow occurs here

    println!("{}", str9);
    // println!("{}", str10)

    // Reference mutable 1
    let mut str11 = String::from("text2");
    {
        let str12 = &mut str11;
        println!("{}", str12);
    }

    let str13 = &mut str11;
    println!("{}", str13);

    // Reference mutable 2
    let mut str14 = String::from("text3");

    let str15 = &str14;
    let str16 = &str14;
    // let str17 = &mut str14; //mutable borrow occurs here

    println!("{}", str15);
    println!("{}", str16);
    // println!("{}", str17);

    // dangling references
    let noth = dang_refr();
    println!();

    // slice
    let mut str17 = String::from("fffirst words");
    let str18 = frst_word(&str17);
    str17.clear();
    println!("{}", str18);

    // string slice
    let str19 = String::from("hello world");
    let str20 = &str19[0..5];
    let str21 = &str19[6..11];
    println!("{},{},{}", str19, str20, str21);

    let str22 = &str19[..5];
    let leng = str19.len();
    let str23 = &str19[6..leng];

    println!("{},{},{}", str22, leng, str23);

    // literal slice
    let mut str24 = String::from("hello world");
    let str25 = frst_word_s(&str24);
    // str24.clear(); // mutable borrow occurs here
    println!("str25 {}", str25);

    // literal slice
    let str26 = String::from("hello world");
    let str27 = frst_word_s(&str26[..]);
    let str28 = "HELLO WORLD";
    let str27 = frst_word_s(&str28[..]);
    let str27 = frst_word_s(str28);
    println!("str27 {}", str27);

    // etc slice
    let intg = [1, 2, 3, 4, 5];
    let ints = &intg[1..3];
    println!("{}{}", ints[0], ints[1])
}

fn take_owns(strg: String) {
    println!("{}", strg);
}

fn make_copy(intg: i32) {
    println!("{}", intg);
}

fn take_back(strg: String) -> String {
    strg
}

fn calc_leng(strg: &String) -> usize {
    strg.len()
}

fn chng_strg(strg: &mut String) {
    strg.push_str(",Hello?");
}

// this function's return type contains a borrowed value
// fn dang_refr() -> &String {
//     let strg = String::from("Eh?");
//     &strg
// }

fn dang_refr() -> String {
    let strg = String::from("Eh?");
    strg
}

fn frst_word(strg: &String) -> usize {
    let bytes = strg.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }
    strg.len()
}

// fn frst_word_s(strg: &String) -> &str {
//     let bytes = strg.as_bytes();

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

fn frst_word_s(strg: &str) -> &str {
    let bytes = strg.as_bytes();

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

struct User {
    name: String,
    mail: String,
    sign: u64,
    actv: bool,
}

fn add_user(mail: String, name: String) -> User {
    User {
        name,
        mail,
        sign: 1,
        actv: true,
    }
}

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

// Struct with reference (Lifetimes)
// struct UserLife {
//     name: &str, // expected named lifetime parameter
//     mail: &str, // expected named lifetime parameter
//     sign: u64,
//     actv: bool,
// }

// struct 1
fn area1(leng: u32, wdth: u32) -> u32 {
    leng * wdth
}

// struct 2
fn area2(dims: (u32, u32)) -> u32 {
    dims.0 * dims.1
}

#[derive(Debug)]
// struct 3
struct Rect {
    leng: u32,
    wdth: u32,
}

fn area3(rect: &Rect) -> u32 {
    rect.leng * rect.wdth
}

#[derive(Debug)]
// struct 4
struct Rectangle {
    length: u32,
    width: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.length * self.width
    }

    fn hold(&self, othr: &Rectangle) -> bool {
        self.length > othr.length && self.width > othr.width
    }

    fn sqre(size: u32) -> Rectangle {
        Rectangle {
            length: size,
            width: size,
        }
    }
}

fn main() {
    // struct
    let user1 = User {
        name: String::from("Jake"),
        mail: String::from("admin@abc.com"),
        sign: 1,
        actv: true,
    };

    let user2 = User {
        name: String::from("Hans"),
        mail: String::from("aaa@abc.com"),
        sign: user1.sign,
        actv: user1.actv,
    };

    let user3 = User {
        name: String::from("Dale"),
        mail: String::from("aaa@abc.com"),
        ..user1
    };

    // tuple
    println!("{}", user1.name);
    println!("{}", user2.name);
    println!("{}", user3.name);

    let blck = Color(0, 0, 0);
    let orgn = Point(0, 0, 0);

    // // struct with reference
    // let user1 = User {
    //     name: String::from("Jake"),
    //     mail: String::from("admin@abc.com"),
    //     sign: 1,
    //     actv: true,
    // };

    let leng = 50;
    let wdth = 30;
    println!("{}", area1(leng, wdth));
    let rect1 = (50, 30);
    println!("{}", area2(rect1));

    let rect2 = Rect { leng: 50, wdth: 30 };
    println!("{}", area3(&rect2));

    // derive(Debug)
    println!("rect is {:?}", rect2);

    // struct implementation
    let rect3 = Rectangle {
        length: 50,
        width: 30,
    };
    println!("{:?},{}", rect3, rect3.area());

    let rect4 = Rectangle {
        length: 50,
        width: 30,
    };
    let rect5 = Rectangle {
        length: 40,
        width: 10,
    };
    let rect6 = Rectangle {
        length: 45,
        width: 60,
    };

    println!("rect4 hold rect5 {}", rect4.hold(&rect5));
    println!("rect4 hold rect6 {}", rect4.hold(&rect6));

    // associated functions
    let sqre = Rectangle::sqre(3);
    println!("sqre : {:?}", sqre)
}

#[derive(Debug)]
enum IpAddrKind {
    V4,
    V6,
}

#[derive(Debug)]
struct IpAddr {
    kind: IpAddrKind,
    addr: String,
}

#[derive(Debug)]
enum IpAddrStr {
    V4(String),
    V6(String),
}

#[derive(Debug)]
enum IpAddrU8 {
    V4(u8, u8, u8, u8),
    V6(String),
}

#[derive(Debug)]
enum IpAddrStrc {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}

#[derive(Debug)]
struct Ipv4Addr {
    addr: String,
}

#[derive(Debug)]
struct Ipv6Addr {
    addr: String,
}

fn route(ip_type: IpAddrKind) {
    println!("{:?}", ip_type)
}

#[derive(Debug)]
enum Mssg {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

impl Mssg {
    fn call(&self) {
        println!("Mssg::call")
    }
}

struct QuitMessage;
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String);
struct ChangeColorMessage(i32, i32, i32);

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

fn main() {
    // enum 1
    let ip4 = IpAddrKind::V4;
    let ip6 = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
    route(ip4);
    route(ip6);

    // enum 2
    let home = IpAddr {
        kind: IpAddrKind::V4,
        addr: String::from("127.0.0.1"),
    };

    let lbck = IpAddr {
        kind: IpAddrKind::V6,
        addr: String::from("::1"),
    };

    println!("{:?}", home);
    println!("{:?}", lbck);

    // enum 3
    let home = IpAddrStr::V4(String::from("127.0.0.1"));
    let lbck = IpAddrStr::V6(String::from("::1"));

    println!("{:?}", home);
    println!("{:?}", lbck);

    // enum 4
    let home = IpAddrU8::V4(127, 0, 0, 1);
    let lbck = IpAddrU8::V6(String::from("::1"));
    println!("{:?}", home);
    println!("{:?}", lbck);

    // enum 5
    let home = IpAddrStrc::V4(Ipv4Addr {
        addr: String::from("127.0.0.1"),
    });
    let lbck = IpAddrStrc::V6(Ipv6Addr {
        addr: String::from("::1"),
    });
    println!("{:?}", home);
    println!("{:?}", lbck);

    // enum 6
    let mssg = Mssg::Write(String::from("Hello"));
    mssg.call();

    // enum 7
    let numb = Some(5);
    let strg = Some("A string");
    let abst: Option<i32> = None;

    println!("{:?}", numb);
    println!("{:?}", strg);
    println!("{:?}", abst);
}

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

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quater(UsState),
}

fn value_in_cents(coin: Coin) -> u32 {
    // enum & match
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quater(state) => {
            println!("State quater from {:?}!", state);
            25
        }
    }
}

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(i) => Some(i + 1),
    }
}

fn main() {
    // enum 1
    let coin1 = Coin::Penny;
    println!("{}", value_in_cents(coin1));

    // enum2
    let coin2 = Coin::Quater(UsState::Alaska);
    println!("{}", value_in_cents(coin2));

    // Option<T> Matching
    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);

    println!("{:?}", five);
    println!("{:?}", six);
    println!("{:?}", none);

    // Placeholder
    let some_u8_value = 0u8;
    match some_u8_value {
        1 => println!("one"),
        3 => println!("three"),
        5 => println!("five"),
        6 => println!("seven"),
        7 => (),
        _ => println!("???"),
    }

    let some_u8_value = Some(3);

    // before if let
    match some_u8_value {
        Some(3) => println!("three"),
        _ => (),
    }

    // after if let (syntax sugar)
    if let Some(3) = some_u8_value {
        println!("Three");
    }

    // let mut / if let else
    let coin2 = Coin::Quater(UsState::Alaska);
    let mut count = 0;
    match coin2 {
        Coin::Quater(state) => println!("State {:?}", state),
        _ => count += 1,
    }
    let coin2 = Coin::Quater(UsState::Alabama);
    if let Coin::Quater(state) = coin2 {
        println!("State {:?}", state);
    } else {
        count += 1;
    }
}

extern crate rust_comm;

pub mod a {
	pub mod sers {
		pub mod of {
			pub fn nest_mods() {}
		}
	}
}

use a::sers::of;
use a::sers::of::nest_mods;

enum TrffLight {
	Red,
	Yellow,
	Green,
}

// use green은 제외
// use TrffLight::{Red, Yellow};
// use에서 전체 포함
use TrffLight::*;

fn main() {
	rust_comm::client::connect();
	// importing names
	a::sers::of::nest_mods();
	// use short type
	of::nest_mods();
	// use short type
	nest_mods();

	let red = Red;
	let yellow = Yellow;
	//let green1 = TrffLight::Green;
	let green2 = Green;
}

// rust_comm
// ⨽ network
// ⨽ client
// // network::connect()
// mod network {
//     fn connect() {
//     }
// }

// // client::connect()
// mod client {
//     fn connect() {
//     }
// }

// rust_comm
// ⨽ network
//   ⨽ client
// network::connect
// network::client::connect
// mod network {
//     fn connect() {}
//     mod client {
//         fn connect() {}
//     }
// }

// rust_comm
// ⨽ client
// ⨽ network
//   ⨽ server
// client
// mod client {
//     fn connect() {
//     }
// }
// // network
// // network::server
// mod network {
//     fn connect() {
//     }
//     mod server {
//         fn connect() {
//         }
//     }
// }

// src/client.rs
pub mod client;

// src/networ.rs
pub mod network;

// src/network/client2.rs
// pub mod client2;

mod outm {
    pub fn midd_func() {}
    pub fn midd_scrt_func() {}

    pub mod insd {
        pub fn innr_func() {}
        pub fn scrt_func() {}
    }
}

fn try_me() {
    outm::midd_func();
    outm::midd_scrt_func();
    outm::insd::innr_func();
    outm::insd::scrt_func();
}

#[cfg(test)]
mod tests {
    use super::client2;

    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
        // client2::connect();
        client2::connect();
    }
}

pub fn connect() {}

pub fn connect() {}

mod server;

fn connect() {}

pub fn connect2() {}

#[derive(Debug)]
enum SpreadsheetCell {
    Int(i32),
    Float(f64),
    Text(String),
}

fn main() {
    // generic
    let v1: Vec<i32> = Vec::new();
    let v1 = vec![1, 2, 3];
    println!("{:?}", v1);

    // push
    let mut v1 = Vec::new();
    v1.push(5);
    v1.push(6);
    v1.push(7);
    v1.push(8);

    println!("{:?}", v1);

    // vector scope
    {
        let v2 = vec![1, 2, 3, 4];
        println!("{:?}", v2);
    }
    // println!("{:?}", v2);

    // get
    let v3 = vec![1, 2, 3, 4, 5];
    let third: &i32 = &v3[2];
    let fourth: Option<&i32> = v3.get(3);
    let sixth: Option<&i32> = v3.get(5);

    println!("{:?},{:?},{:?}", third, fourth, sixth);

    // Vecto Push (???)
    let mut v4 = vec![1, 2, 3, 4, 5];
    let second = &v4[1];
    v4.push(6);
    println!("{:?}", v4);

    // Vector + for
    let v5 = vec![10, 3, 2, 5, 7];
    for i in &v5 {
        println!("{}", i);
    }
    println!("{:?}", v5);

    // Vector + for
    let mut v5 = vec![10, 3, 2, 5, 7];
    for i in &mut v5 {
        *i += 50;
        println!("{}", i);
    }
    println!("{:?}", v5);

    // enum
    let row = vec![
        SpreadsheetCell::Int(3),
        SpreadsheetCell::Text(String::from("Blue")),
        SpreadsheetCell::Float(10.12),
    ];
    println!("{:?}", row);
}

fn main() {
    // str1
    let mut str1 = String::new();
    let str1 = "hello there?";
    // str2
    let dat1 = "initial contents";
    let str2 = dat1.to_string();
    let str2 = "initial contents".to_string();

    // str3
    let str3 = String::from("This is Pen");
    println!("{} , {} , {}", str1, str2, str3);

    // str utf8
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שָׁלוֹם");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");

    println!("{}", hello);

    // push
    let mut str4 = String::from("foo");
    str4.push_str("bar");
    str4.push_str("quz");

    println!("{}", str4);

    // push_str : ownership
    let mut str5 = String::from("foo");
    let str6 = "bar";
    str5.push_str(&str6);
    println!("{} , {}", str5, str6);

    // push (lol)
    let mut str7 = String::from("lo");
    str7.push('l');
    println!("{}", str7);

    // combine
    let str8 = String::from("Hello,");
    let str9 = String::from("World!");
    // let str10 = str8 + str9; //expected `&str`, found struct `std::string::String`
    // add moethod -> fn add(self, s: &str) -> String {}
    // &String -> &str : deref coercion
    let str10 = str8 + &str9;
    //println!("{}", str8); //value borrowed here after move
    println!("{}", str9);
    println!("{}", str10);

    // +
    let str11 = String::from("tic");
    let str12 = String::from("tac");
    let str13 = String::from("toe");

    let str14 = str11 + "-" + &str12 + "-" + &str13;
    // println!("{}", str11);
    println!("{}", str12);
    println!("{}", str13);
    println!("{}", str14);

    // format!
    let str11 = String::from("tic");
    let str15 = format!("{}-{}-{}", str11, str12, str13);
    println!("{}", str15);

    let str16 = String::from("hello wrold");
    //let str17 = str16[3]; //std::string::String` cannot be indexed by
    // "Hello" "Здравствуйте" "안녕하십니까" &str16[0] = ???
    let str17 = &str16[0..4];
    println!("{}", str17);

    // Panic
    // let str16 = String::from("안녕하십니까");
    // let str17 = &str16[0..1];
    // println!("{}", str17);

    // string for
    for chr in "안녕하십니까?".chars() {
        println!("{}", chr);
    }
    // string for
    for byt in "안녕하십니까?".bytes() {
        println!("{}", byt);
    }
}

use std::collections::HashMap;

fn main() {
    // Hash map 1
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    println!("{:?}", scores);

    // hash map 2
    let teams = vec![String::from("Blue"), String::from("Yellow")];
    let init_scores = vec![10, 50];
    let score2: HashMap<_, _> = teams.iter().zip(init_scores.iter()).collect();

    println!("{:?}", score2);

    let field_nm = String::from("favorite color");
    let field_val = String::from("Blue");

    let mut map = HashMap::new();
    map.insert(field_nm, field_val);
    //println!("{:?}", field_nm); // value borrowed here after move
    println!("{:?}", map);

    // hash map 3
    let team_nm = String::from("Blue");
    let score = scores.get(&team_nm);
    println!("{:?}", score);

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

    // hashmap insert
    scores.insert(String::from("Blue"), 25);

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

    // hashmap or insert
    scores.entry(String::from("Red")).or_insert(15);

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

    let text = "Hello World Wonderful World Very Wonderful World And Hello Agin";
    let mut map = HashMap::new();

    for word in text.split_whitespace() {
        let count = map.entry(word).or_insert(0); // return &mut V
        *count += 1;
    }

    println!("{:?}", map);
}

use std::fs::File;
use std::io;
// use std::io::ErrorKind;
use std::io::Read;

// enum Result<T, E> {
//     Ok(T),
//     Err(E),
// }

fn read_from_file1() -> Result<String, io::Error> {
    let f = File::open("not_exist_file.txt");

    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut s = String::new();

    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}

fn read_from_file2() -> Result<String, io::Error> {
    let mut f = File::open("not_exist_file.txt")?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

fn read_from_file3() -> Result<String, io::Error> {
    let mut s = String::new();
    File::open("not_exist_file.txt")?.read_to_string(&mut s)?;
    Ok(s)
}

fn main() {
    // panic direct call
    // panic!("crash and burn");
    // println!("Hello, world!");

    // panic library call (buffer overread)
    // let v = vec![1, 2, 3];
    // v[99];

    // RUST_BACKTRACE=full cargo run

    // Error
    // let f: u32 = File::open("not_exists_file.txt");

    // Error Match
    // let f = File::open("not_exists_file.txt");
    // let f = match f {
    //     Ok(file) => file,
    //     Err(ref error) if error.kind() == ErrorKind::NotFound => {
    //         match File::create("not_exists_file.txt") {
    //             Ok(fc) => fc,
    //             Err(e) => panic!("Tried Create {:?}", e),
    //         }
    //     }
    //     Err(error) => panic!("Error {:?}", error),
    // };

    // Error with unwrap
    // let f = File::open("not_exists_file.txt").unwrap();

    // Error with expect
    // let f = File::open("not_exists_file.txt").expect("Failed");

    // Error propagating
    read_from_file1();

    // Error propagating 2
    read_from_file2();

    // Error propagating 3
    read_from_file3();

    // ? without return Error
    // let x = File::open("not_exists_file.txt")?;
}

fn find_max_num(nums: &[i32]) -> i32 {
    let mut num_max = nums[0];

    for &num in nums.iter() {
        if num > num_max {
            num_max = num;
        }
    }

    num_max
}

fn find_max_chr(chrs: &[char]) -> char {
    let mut chr_max = chrs[0];

    for &chr in chrs.iter() {
        if chr > chr_max {
            chr_max = chr;
        }
    }

    chr_max
}

fn find_max<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut item_max = list[0];

    for &item in list.iter() {
        if item > item_max {
            item_max = item;
        }
    }

    item_max
}

fn main() {
    // Find Max Number 1
    let nums = vec![34, 50, 2, 5, 100, 65];
    let mut num_max = nums[0];

    for num in nums {
        if num > num_max {
            num_max = num;
        }
    }

    println!("Number Max : {:?}", num_max);

    // Find Max Number 2
    let nums = vec![102, 34, 6000, 89, 54, 2, 43, 8];

    let mut num_max = nums[0];

    for num in nums {
        if num > num_max {
            num_max = num;
        }
    }

    println!("Number Max : {:?}", num_max);

    // Find Max Number 3
    let nums = vec![10, 60, 150, 59, 34, 22, 13, 80];
    let num_max = find_max_num(&nums);
    println!("Number Max : {:?}", num_max);

    // Find Max Chars 4
    let chrs = vec!['a', 'c', 'd', 'e', 'g', 'z'];
    let chr_max = find_max_chr(&chrs);
    println!("Chars Max : {:?}", chr_max);

    // Find Max 5
    let nums = vec![10, 60, 150, 59, 34, 22, 13, 80];
    let chrs = vec!['a', 'c', 'd', 'e', 'g', 'z'];
    let num_max = find_max(&nums);
    let chr_max = find_max(&chrs);
    println!("Number Max : {:?} , Chars Max : {:?}", num_max, chr_max);

    // generic data type 1
    let int1 = Point1 { x: 5, y: 10 };
    let flt1 = Point1 { x: 1.0, y: 3.0 };
    println!("{:?},{:?}", int1, flt1);

    // let not_work = Point { x: 5, y: 3.0 };

    // generic data type 2
    let int1 = Point2 { x: 5, y: 10 };
    let flt1 = Point2 { x: 1.0, y: 3.0 };
    let mix1 = Point2 { x: 5, y: 3.0 };

    println!("{:?},{:?},{:?}", int1, flt1, mix1);

    // generic type with method
    let int1 = Point1 { x: 3, y: 8 };
    println!("int1.x = {}, int1.y = {}", int1.x(), int1.y());

    // generic type with method 2
    let pnt1 = Point2 { x: 3, y: 10.5 };
    let pnt2 = Point2 { x: "Text", y: 'H' };
    let pnt3 = pnt1.mixup(pnt2);
    println!("{:?}", pnt3);

    // zero cost generic <-- monomorphization
}

#[derive(Debug)]
struct Point1<T> {
    x: T,
    y: T,
}

impl<T> Point1<T> {
    fn x(&self) -> &T {
        &self.x
    }
    fn y(&self) -> &T {
        &self.y
    }
}

#[derive(Debug)]
struct Point2<A, B> {
    x: A,
    y: B,
}

impl<A, B> Point2<A, B> {
    fn mixup<C, D>(self, other: Point2<C, D>) -> Point2<A, D> {
        Point2 {
            x: self.x,
            y: other.y,
        }
    }
}

pub trait Summarizable {
	fn summary(&self) -> String;
}

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

impl Summarizable for NewsArticle {
	fn summary(&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 Summarizable for Tweet {
	fn summary(&self) -> String {
		format!("{}: {}", self.username, self.content)
	}
}

pub fn notify<T: Summarizable> (item: T) { println!("Breaking news! {}", item.summary());}

mod lib;

use lib::Summarizable;
use lib::Tweet;

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!("1 new tweet: {}", tweet.summary());
}

use std::fmt::Display;

fn main() {
    // dangligh reference 1
    {
        let r;
        {
            let x = 5;
            r = &x;
        }

        // println!("r: {}", r); // borrow later used here
    }

    // lifetime 1
    let str1 = String::from("abcd");
    let str2 = "xyz";

    let rst1 = str_long(str1.as_str(), str2);
    println!("the longest string is {}", rst1);

    // lifetime 2
    let str1 = String::from("long string is long");
    {
        let str2 = String::from("xyz");
        let rst1 = str_long(str1.as_str(), str2.as_str());
        println!("the longest string is {}", rst1);
    }
    // lifetime 3
    let str1 = String::from("long string is long");
    let rst2;
    {
        let str2 = String::from("xyz");
        rst2 = str_long(str1.as_str(), str2.as_str());
    }
    // println!("the longest string is {}", rst2);

    // struct lifetime
    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!("{:?}", i);

    // static lifetime
    let s: &'static str = "I have a static lifetime.";

    let str1 = String::from("abcd");
    let str2 = String::from("efg");
    // long with announce
    let rst3 = long_with_an_annc(str1.as_str(), str2.as_str(), "what?");
    println!("{}", rst3);
}

// lifetime 명시
fn str_long<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// lifetime 명시 1
fn str_lon1<'a>(x: &'a str, y: &str) -> &'a str {
    x
}

// // lifetime 명시 2 // error
// fn str_lon2<'a>(x: &str, y: &str) -> &'a str {
//     let result = String::from("long string");
//     result.as_str()
// }

#[derive(Debug)]
struct ImportantExcerpt<'a> {
    part: &'a str,
}

// fn first_word<'a>(s: &'a str) -> &'a str {...}
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[..]
}

fn long_with_an_annc<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a str
where
    T: Display,
{
    println!("Announcement! {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

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

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

pub fn add_two(a: i32) -> i32 {
    a + 2
}

pub fn greeting(name: &str) -> String {
    format!("Hello {}!", name)
}

pub fn just_greeting(name: &str) -> String {
    format!("Hello!")
}

pub struct Guess {
    value: u32,
}

impl Guess {
    pub fn new(value: u32) -> Guess {
        if value < 1 || value > 100 {
            panic!("Guess value must be between 1 and 100, got {}.", value);
        }

        Guess { value }
    }
    pub fn new_new(value: u32) -> Guess {
        if value < 1 {
            panic!("Guess value must be between 1 and 100, got {}.", value);
        }

        Guess { value }
    }
    pub fn new_new_new(value: u32) -> Guess {
        if value < 1 {
            panic!("Value < 1, got {}.", value);
        } else if value > 100 {
            panic!("Value > 100, got {}.", value);
        }

        Guess { value }
    }
}

fn prints_and_returns_10(a: i32) -> i32 {
    println!("I got the value {}", a);
    10
}

pub fn add_two_num(a: i32) -> i32 {
    internal_adder(a, 2)
}

fn internal_adder(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    #[test]
    fn it_works_1() {
        assert_eq!(2 + 2, 4);
    }

    #[test]
    fn it_works_2() {
        assert_eq!(3 + 3, 6);
    }

    #[test]
    fn it_works_3() {
        assert_eq!(3 + 3, 4);
    }

    #[test]
    fn it_works_4() {
        panic!("Make this fail");
    }

    use super::*;

    #[test]
    fn larger_can_hold_smaller() {
        let larger = Rectangle {
            length: 8,
            width: 7,
        };
        let smaller = Rectangle {
            length: 5,
            width: 1,
        };

        assert!(larger.can_hold(&smaller));
    }

    #[test]
    fn smaller_cannot_hold_larger() {
        let larger = Rectangle {
            length: 8,
            width: 7,
        };
        let smaller = Rectangle {
            length: 5,
            width: 1,
        };

        assert!(!smaller.can_hold(&larger));
    }

    #[test]
    fn it_adds_two() {
        assert_eq!(4, add_two(2));
    }

    #[test]
    fn it_adds_two_ne() {
        assert_ne!(5, add_two(2));
    }

    #[test]
    fn greeting_contains_name() {
        let result = greeting("Carol");
        assert!(result.contains("Carol"));
    }

    #[test]
    fn greeting_without_name() {
        let result = just_greeting("Carol");
        assert!(
            result.contains("Carol"),
            "Greeting did not contain name, value was `{}`",
            result
        );
    }

    #[test]
    #[should_panic]
    fn greater_than_100() {
        Guess::new(200);
    }

    #[test]
    #[should_panic]
    fn greater_than_100_2() {
        Guess::new_new(200);
    }

    #[test]
    #[should_panic(expected = "Value > 100")]
    fn greater_than_100_3() {
        Guess::new_new_new(200);
    }

    #[test]
    #[should_panic(expected = "Value < 1")]
    fn greater_than_100_4() {
        Guess::new_new_new(200);
    }

    #[test]
    #[should_panic(expected = "Value")]
    fn greater_than_100_5() {
        Guess::new_new_new(200);
    }

    // cargo test -- --help
    // cargo test -- --test-threads=1

    // cargo test -- --nocapture
    // cargo test this_test_will_pass
    // cargo test this_test_will_pass -- --nocapture
    // cargo test this_test_will
    #[test]
    fn this_test_will_pass() {
        let value = prints_and_returns_10(4);
        assert_eq!(10, value);
    }

    #[test]
    fn this_test_will_fail() {
        let value = prints_and_returns_10(8);
        assert_eq!(5, value);
    }

    // cargo test this_test_will -- --ignored
    #[test]
    #[ignore]
    fn this_test_will_expensive_test() {
        let value = prints_and_returns_10(8);
        assert_eq!(5, value);
    }

    // unit test
    use super::*;

    #[test]
    fn internal() {
        assert_eq!(4, internal_adder(2, 2));
    }
}

extern crate rust_test;

mod common;

// cargo test : integrated test
// cargo test --test intg_test
#[test]
fn it_adds_twx() {
	common::setup();
	assert_eq!(4, rust_test::add_two_num(2));
}

pub fn setup() {
	println!("TEST WOW")
}

use std::env;
use std::error::Error;
use std::fs::File;
use std::io::prelude::*;

pub struct Config {
	pub pgnm: String,
	pub quer: String,
	pub file: String,
	pub case: bool,
}

impl Config {
	pub fn new(args: &[String]) -> Result<Config, &'static str> {
		if args.len() < 3 {
			panic!("not enough arguments");
		}

		let pgnm = args[0].clone();
		let quer = args[1].clone();
		let file = args[2].clone();
		let case = env::var("CASE").is_err();

		Ok(Config {
			pgnm,
			quer,
			file,
			case,
		})
	}
}

pub fn run(conf: Config) -> Result<(), Box<Error>> {
	let mut f = File::open(conf.file)?;
	let mut cont = String::new();
	f.read_to_string(&mut cont)?;

	let rslt = if conf.case {
		search(&conf.quer, &cont)
	} else {
		search_case_insensitive(&conf.quer, &cont)
	};

	//println!("With text:\n {}", cont);
	for line in rslt {
		println!("{}", line)
	}

	Ok(())
}

#[cfg(test)]
mod test {
	use super::*;

	#[test]
	fn one_result() {
		let quer = "duct";
		let cont = "\
Rust:alloc
safe, fast, productive.
Pick three.";

		assert_eq!(vec!["safe, fast, productive."], search(quer, cont));
	}

	#[test]
	fn case_insensitive() {
		let quer = "rUsT";
		let cont = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";

		assert_eq!(
			vec!["Rust:", "Trust me."],
			search_case_insensitive(quer, cont)
		);
	}
}

pub fn search<'a>(quer: &str, cont: &'a str) -> Vec<&'a str> {
	let mut rslt = Vec::new();

	for line in cont.lines() {
		if line.contains(quer) {
			rslt.push(line);
		}
	}
	rslt
}

pub fn search_case_insensitive<'a>(quer: &str, cont: &'a str) -> Vec<&'a str> {
	let quer = quer.to_lowercase();
	let mut rslt = Vec::new();

	for line in cont.lines() {
		if line.to_lowercase().contains(&quer) {
			rslt.push(line);
		}
	}

	rslt
}

extern crate rust_grep;

use rust_grep::Config;
use std::env;
use std::process;

fn main() {
    let args: Vec<String> = env::args().collect();
    //let conf = parse_config(&args);
    let conf = Config::new(&args).unwrap_or_else(|err| {
        println!("Problem parsing arguments: {}", err);
        process::exit(1);
    });

    println!("Program Name : {}", conf.pgnm);
    println!("Searching for : {}", conf.quer);
    println!("In file : {}", conf.file);

    // let mut f = File::open(conf.file).expect("file not found");
    // let mut cont = String::new();
    // f.read_to_string(&mut cont)
    //     .expect("Something went wrong reading the file");
    // println!("With text:\n {}", cont);

    if let Err(e) = rust_grep::run(conf) {
        eprintln!("Application Error : {}", e);
        process::exit(1);
    }
}

// fn parse_config(args: &[String]) -> Config {
//     let pgnm = args[0].clone();
//     let quer = args[1].clone();
//     let file = args[2].clone();

//     Config { pgnm, quer, file }
// }