[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct User {
    name: String,
    email: String,
    age: u32,
    #[serde(default)]
    active: bool,
}

fn main() {
    let user = User {
        name: "Alice".to_string(),
        email: "alice@example.com".to_string(),
        age: 30,
        active: true,
    };

    // 序列化到 JSON
    let json = serde_json::to_string_pretty(&user).unwrap();
    println!("JSON:\n{}", json);

    // 从 JSON 反序列化
    let json_str = r#"{"name":"Bob","email":"bob@example.com","age":25}"#;
    let user2: User = serde_json::from_str(json_str).unwrap();
    println!("反序列化: {:?}", user2);
}

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Config {
    #[serde(rename = "serverHost")]
    host: String,

    #[serde(default = "default_port")]
    port: u16,

    #[serde(skip_serializing_if = "Option::is_none")]
    password: Option<String>,

    #[serde(skip)]
    internal: bool,
}

fn default_port() -> u16 {
    8080
}

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

use tokio::time::{sleep, Duration};
use tokio::fs;

#[tokio::main]
async fn main() {
    // 异步文件操作
    fs::write("test.txt", "hello").await.unwrap();
    let content = fs::read_to_string("test.txt").await.unwrap();
    println!("文件内容: {}", content);

    // 并发任务
    let mut handles = vec![];
    for i in 0..5 {
        handles.push(tokio::spawn(async move {
            sleep(Duration::from_millis(100 * i)).await;
            format!("任务{}完成", i)
        }));
    }

    for handle in handles {
        println!("{}", handle.await.unwrap());
    }

    // 清理
    let _ = fs::remove_file("test.txt").await;
}

[dependencies]
reqwest = { version = "0.12", features = ["json"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }

use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct Todo {
    id: u32,
    title: String,
    completed: bool,
}

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    // GET 请求
    let todos: Vec<Todo> = reqwest::get("https://jsonplaceholder.typicode.com/todos?_limit=5")
        .await?
        .json()
        .await?;

    for todo in &todos {
        println!("[{}] {}", if todo.completed { "✓" } else { " " }, todo.title);
    }

    // POST 请求
    let client = reqwest::Client::new();
    let new_todo = serde_json::json!({
        "title": "学习 Rust",
        "completed": false,
        "userId": 1
    });

    let resp = client.post("https://jsonplaceholder.typicode.com/todos")
        .json(&new_todo)
        .send()
        .await?;

    println!("创建状态: {}", resp.status());

    Ok(())
}

[dependencies]
clap = { version = "4", features = ["derive"] }

use clap::Parser;

#[derive(Parser, Debug)]
#[command(name = "mytool")]
#[command(about = "一个示例命令行工具")]
struct Args {
    /// 输入文件
    #[arg(short, long)]
    input: String,

    /// 输出文件（可选）
    #[arg(short, long, default_value = "output.txt")]
    output: String,

    /// 详细模式
    #[arg(short, long)]
    verbose: bool,

    /// 并发数
    #[arg(short, long, default_value_t = 4)]
    workers: usize,
}

fn main() {
    let args = Args::parse();

    println!("输入: {}", args.input);
    println!("输出: {}", args.output);
    println!("详细: {}", args.verbose);
    println!("并发: {}", args.workers);
}

[dependencies]
clap = { version = "4", features = ["derive"] }
reqwest = { version = "0.12", features = ["json"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
anyhow = "1"

use clap::Parser;
use serde::Deserialize;
use anyhow::Result;

#[derive(Parser)]
#[command(name = "weather")]
struct Args {
    /// 城市名
    city: String,
}

#[derive(Deserialize, Debug)]
struct WeatherResponse {
    location: Location,
    current: Current,
}

#[derive(Deserialize, Debug)]
struct Location {
    name: String,
    country: String,
}

#[derive(Deserialize, Debug)]
struct Current {
    temp_c: f64,
    condition: Condition,
}

#[derive(Deserialize, Debug)]
struct Condition {
    text: String,
}

#[tokio::main]
async fn main() -> Result<()> {
    let args = Args::parse();

    // 注意：需要替换为真实的 API key
    println!("查询 {} 的天气...", args.city);
    println!("（示例输出）");
    println!("城市: {}", args.city);
    println!("温度: 25.0°C");
    println!("天气: 晴朗");

    Ok(())
}