#Rust Environment Setup

// Rust toolchain contains the following components:
// - rustc: Rust compiler
// - cargo: Package manager and build tool
// - rustfmt: Code formatting tool
// - clippy: Code linting tool
// - rust-docs: Local documentation

// Install Rust plugin
// File -> Settings -> Plugins -> Search "Rust"
// Install "Rust" plugin

// Configure Rust toolchain
// File -> Settings -> Languages & Frameworks -> Rust
// Toolchain location: ~/.cargo/bin
// Standard library: ~/.rustup/toolchains/stable-x86_64-unknown-linux-gnu

// hello_rust/
// ├── Cargo.toml    # Project configuration file
// ├── src/          # Source code directory
// │   └── main.rs   # Main program file
// └── target/       # Compilation output directory (created after build)

// Cargo.toml example
[package]
name = "hello_rust"
version = "0.1.0"
edition = "2021"

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

[dev-dependencies]
assert_cmd = "2.0"

// src/main.rs
fn main() {
    println!("Hello, Rust!");

    // Variables and type inference
    let name = "World";
    let number = 42;

    println!("Hello, {}! Lucky number is {}", name, number);

    // Mutable variable
    let mut count = 0;
    count += 1;
    println!("Counter: {}", count);

    // Function call
    let result = add_numbers(10, 20);
    println!("10 + 20 = {}", result);
}

fn add_numbers(a: i32, b: i32) -> i32 {
    a + b // No semicolon, indicates return value
}

// Clippy example
fn inefficient_function() {
    let mut vec = Vec::new();
    for i in 0..10 {
        vec.push(i); // Clippy suggests: use (0..10).collect()
    }

    let s = "hello".to_string();
    if s == "hello" { // Clippy suggests: compare &str directly
        println!("match!");
    }
}

// Improved code
fn efficient_function() {
    let vec: Vec<i32> = (0..10).collect();

    let s = "hello";
    if s == "hello" {
        println!("match!");
    }
}

// rust-analyzer provides:
// 1. Intelligent completion
// 2. Error checking
// 3. Type hints
// 4. Refactoring tools
// 5. Code navigation

fn example_function() {
    let numbers = vec![1, 2, 3, 4, 5];

    // rust-analyzer will provide:
    // - Type hint for numbers: Vec<i32>
    // - Auto-completion for .iter() method
    // - Error diagnostics and fix suggestions
    let sum: i32 = numbers.iter().sum();
    println!("Sum: {}", sum);
}

// src/main.rs
use std::collections::HashMap;

fn main() {
    println!("🦀 Rust Environment Test");

    // Test basic syntax
    test_basic_syntax();

    // Test standard library
    test_standard_library();

    // Test external dependencies (need to add in Cargo.toml)
    test_external_crate();
}

fn test_basic_syntax() {
    println!("\n✅ Basic Syntax Test");

    let message = "Hello, Rust!";
    let numbers = vec![1, 2, 3, 4, 5];
    let sum: i32 = numbers.iter().sum();

    println!("Message: {}", message);
    println!("Array sum: {}", sum);
}

fn test_standard_library() {
    println!("\n✅ Standard Library Test");

    let mut map = HashMap::new();
    map.insert("language", "Rust");
    map.insert("type", "Systems Programming");

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

fn test_external_crate() {
    println!("\n✅ External Dependency Test");
    // If serde dependency is added, serialization can be tested
    println!("External crate works correctly");
}

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

    #[test]
    fn test_string_operations() {
        let s = String::from("hello");
        assert_eq!(s.len(), 5);
    }
}

// benches/my_benchmark.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn fibonacci(n: u64) -> u64 {
    match n {
        0 => 1,
        1 => 1,
        n => fibonacci(n-1) + fibonacci(n-2),
    }
}

fn criterion_benchmark(c: &mut Criterion) {
    c.bench_function("fib 20", |b| b.iter(|| fibonacci(black_box(20))));
}

criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);