// Firefox 내부 코드의 전형적인 메모리 버그
void processRequest(const char* url) {
  char* buffer = (char*)malloc(1024);
  
  // 수많은 코드들...
  if (error) {
    return;  // 💥 메모리 누수!
  }
  
  // 더 많은 코드들...
  free(buffer);
  
  // 다른 곳에서
  processData(buffer);  // 💥 use-after-free!
}

// C++의 강력함: 하드웨어를 직접 제어
void processImage(uint8_t* pixels, size_t width, size_t height) {
  // 메모리 직접 접근 = 최고의 성능
  for (size_t i = 0; i < width * height * 4; i += 4) {
    pixels[i] = enhance(pixels[i]);       // R
    pixels[i+1] = enhance(pixels[i+1]);   // G
    pixels[i+2] = enhance(pixels[i+2]);   // B
    // pixels[i+3]는 alpha, 건드리지 않음
  }
  // 캐시 친화적, SIMD 최적화 가능, 제로 오버헤드
}

// 전형적인 C++ 메모리 관리의 악몽

// 1. 메모리 누수 (Memory Leak)
void loadConfig() {
  Config* config = new Config();
  if (config->parse() == false) {
    return;  // 💥 config가 해제되지 않음!
  }
  // ...
  delete config;
}

// 2. Use-after-free
std::vector<User*> users;
User* user = new User("Alice");
users.push_back(user);
delete user;
// 나중에...
users[0]->getName();  // 💥 이미 해제된 메모리 접근!

// 3. Double free
char* data = (char*)malloc(100);
free(data);
// 복잡한 로직...
free(data);  // 💥 이미 해제된 메모리를 또 해제!

// 4. 버퍼 오버플로우
char buffer[10];
strcpy(buffer, "This is a very long string");  // 💥

// 5. 데이터 레이스 (Data Race)
int counter = 0;
// Thread 1
counter++;
// Thread 2 (동시에)
counter++;  // 💥 예측 불가능한 결과

// 그레이돈의 비전: 이 세 가지를 동시에
- 메모리 안전성 (Memory Safety)
- 동시성 안전성 (Concurrency Safety)  
- C/C++ 수준의 성능 (Zero-cost Abstractions)

// Servo의 목표: 병렬 렌더링 엔진
// CSS 파싱, 레이아웃, 렌더링을 모두 병렬로
// 하지만 메모리 안전성과 동시성 안전성을 보장하면서

// 이것이 가능하려면 언어 자체가 달라져야 했음

// Rust의 Ownership 규칙 (컴파일러가 강제함)

// 규칙 1: 모든 값은 소유자(owner)가 있다
let s = String::from("hello");  // s가 문자열의 소유자

// 규칙 2: 한 번에 하나의 소유자만 존재
let s2 = s;  // 소유권이 s에서 s2로 이동 (move)
// println!("{}", s);  // ❌ 컴파일 에러! s는 더 이상 유효하지 않음

// 규칙 3: 소유자가 스코프를 벗어나면 값은 자동으로 해제됨
{
  let s = String::from("hello");
  // s 사용...
}  // 여기서 s가 자동으로 drop됨. free() 호출 필요 없음!

// C++에서는 이런 실수가 가능
void process() {
  std::string* s = new std::string("hello");
  // 뭔가 복잡한 로직...
  if (error) return;  // 💥 메모리 누수!
  delete s;
}

// Rust에서는 컴파일러가 방지
fn process() {
  let s = String::from("hello");
  // 뭔가 복잡한 로직...
  if error { return; }  // ✅ s는 자동으로 drop됨
  // 명시적 해제 불필요
}

// Borrowing: 소유권 없이 값을 사용

fn main() {
  let s = String::from("hello");
  
  // 불변 참조 (immutable reference)
  let len = calculate_length(&s);  // &s는 s를 빌림
  println!("{}", s);  // ✅ s는 여전히 유효!
  
  // 가변 참조 (mutable reference)
  change(&mut s);
}

fn calculate_length(s: &String) -> usize {
  s.len()  // s는 참조일 뿐, 소유권은 없음
}  // s가 스코프를 벗어나지만, 소유권이 없으므로 drop되지 않음

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

// C++에서 흔한 use-after-free 버그
std::vector<int*> vec;
int* ptr = new int(5);
vec.push_back(ptr);
delete ptr;
int value = *vec[0];  // 💥 use-after-free!

// Rust에서는 컴파일이 안 됨
let mut vec: Vec<&i32> = Vec::new();
let x = 5;
vec.push(&x);
drop(x);  // ❌ 컴파일 에러!
// error: cannot move out of `x` because it is borrowed

// C++에서 흔한 데이터 레이스
int counter = 0;
std::thread t1([&]() { counter++; });
std::thread t2([&]() { counter++; });  // 💥 데이터 레이스!
t1.join();
t2.join();

// Rust에서는 컴파일이 안 됨
let mut counter = 0;
let handle1 = std::thread::spawn(|| {
  counter += 1;  // ❌ 컴파일 에러!
});
// error: closure may outlive the current function
// help: to force the closure to take ownership, use `move`

// 올바른 방법: Mutex 사용
use std::sync::{Arc, Mutex};
let counter = Arc::new(Mutex::new(0));
let counter1 = Arc::clone(&counter);
let handle1 = std::thread::spawn(move || {
  let mut num = counter1.lock().unwrap();
  *num += 1;  // ✅ 안전!
});

// Rust 코드
fn sum(numbers: &[i32]) -> i32 {
  numbers.iter().sum()
}

// 컴파일 후 어셈블리는 C와 동일한 수준
// 런타임 오버헤드 제로!

// C/C++에서는 전문가만 안전하게 작성 가능했던 코드
// Rust에서는 초보자도 안전하게 작성 가능

// 파일 읽기 (에러 처리 포함)
use std::fs::File;
use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {
  let mut file = File::open(path)?;  // ? 연산자로 에러 전파
  let mut contents = String::new();
  file.read_to_string(&mut contents)?;
  Ok(contents)
}

// 컴파일러가 모든 에러 케이스를 강제로 처리하게 함
// "예외"가 없음 - 모든 에러는 타입으로 표현됨

// Linux 커널 드라이버를 Rust로 작성 가능!
#![no_std]  // 표준 라이브러리 없음 (커널 환경)

use kernel::prelude::*;

module! {
  type: RustMinimal,
  name: "rust_minimal",
  author: "Rust for Linux Contributors",
  description: "Minimal Rust kernel module",
  license: "GPL",
}

struct RustMinimal;

impl kernel::Module for RustMinimal {
  fn init(_module: &'static ThisModule) -> Result<Self> {
    pr_info!("Hello from Rust!\n");
    Ok(RustMinimal)
  }
}

# Cargo.toml - 프로젝트 설정
[package]
name = "my-project"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

# 단 한 줄로 빌드, 테스트, 실행
cargo build    # 빌드
cargo test     # 테스트 실행
cargo run      # 실행
cargo publish  # crates.io에 배포

// 초보자의 전형적인 경험
fn first_word(s: &String) -> &str {
  let bytes = s.as_bytes();
  for (i, &item) in bytes.iter().enumerate() {
    if item == b' ' {
      return &s[0..i];
    }
  }
  &s[..]
}

// 이 코드를 작성하는 데 1시간...
// 컴파일러 에러를 고치는 데 3시간...
// "lifetime이 뭔데?!" 😤

error[E0382]: borrow of moved value: `s`
  --> src/main.rs:4:20
   |
2  |   let s = String::from("hello");
   |       - move occurs because `s` has type `String`
3  |   let s2 = s;
   |            - value moved here
4  |   println!("{}", s);
   |                  ^ value borrowed here after move
   |
help: consider cloning the value if the performance cost is acceptable
   |
3  |   let s2 = s.clone();
   |             ++++++++

// 단순히 "에러"만 말하는 게 아니라
// 무엇이 문제인지, 왜 문제인지, 어떻게 고칠지까지 알려줌!

// Tokio를 사용한 비동기 웹 서버
use tokio::net::TcpListener;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
  let listener = TcpListener::bind("127.0.0.1:8080").await?;
  
  loop {
    let (socket, _) = listener.accept().await?;
    
    // 각 연결을 별도 태스크로 처리
    tokio::spawn(async move {
      process(socket).await;
    });
  }
}

// C++의 복잡한 비동기 코드 없이
// Go의 goroutine처럼 쉽게
// 하지만 제로 오버헤드로!

// 메모리 안전성 ✓
// 동시성 안전성 ✓  
// C/C++ 수준의 성능 ✓

// 오늘날 Rust 개발자들이 당연하게 여기는 것

fn main() {
  let data = vec![1, 2, 3, 4, 5];
  
  // 병렬 처리
  let sum: i32 = data.par_iter().sum();
  
  // 메모리 안전성? 걱정 없음
  // 데이터 레이스? 컴파일 에러로 잡힘
  // Segfault? 그게 뭔데?
  
  println!("Sum: {}", sum);  // 그냥 작동함
}