use std::io;

fn main() {
    println!("Qual é o seu nome?");

    let mut nome = String::new();
    io::stdin()
        .read_line(&mut nome)
        .expect("Erro ao ler entrada");

    // trim() remove o \n do final
    let nome = nome.trim();

    println!("Olá, {}! Bem-vindo ao Rust.", nome);
}

use std::io;

fn ler_linha() -> String {
    let mut entrada = String::new();
    io::stdin()
        .read_line(&mut entrada)
        .expect("Erro ao ler entrada");
    entrada.trim().to_string()
}

fn main() {
    println!("Digite sua idade:");
    let idade: u32 = ler_linha()
        .parse()
        .expect("Por favor, digite um número válido");

    println!("Digite sua altura em metros (ex: 1.75):");
    let altura: f64 = ler_linha()
        .parse()
        .expect("Por favor, digite um número decimal válido");

    println!("\nVocê tem {} anos e {:.2}m de altura.", idade, altura);

    let ano_nascimento = 2026 - idade;
    println!("Você nasceu por volta de {}.", ano_nascimento);
}

use std::io;
use std::io::Write;

fn ler_numero(prompt: &str, min: f64, max: f64) -> f64 {
    loop {
        print!("{}", prompt);
        io::stdout().flush().unwrap(); // garantir que o prompt aparece

        let mut entrada = String::new();
        io::stdin().read_line(&mut entrada).unwrap();

        match entrada.trim().parse::<f64>() {
            Ok(n) if n >= min && n <= max => return n,
            Ok(n) => {
                println!("Valor {:.2} fora do intervalo ({:.0} a {:.0}). Tente novamente.", n, min, max);
            }
            Err(_) => {
                println!("'{}' não é um número válido. Tente novamente.", entrada.trim());
            }
        }
    }
}

fn ler_opcao(prompt: &str, opcoes: &[&str]) -> String {
    loop {
        print!("{} [{}]: ", prompt, opcoes.join("/"));
        io::stdout().flush().unwrap();

        let mut entrada = String::new();
        io::stdin().read_line(&mut entrada).unwrap();
        let entrada = entrada.trim().to_lowercase();

        if opcoes.contains(&entrada.as_str()) {
            return entrada;
        }
        println!("Opção inválida. Escolha entre: {}", opcoes.join(", "));
    }
}

fn main() {
    println!("=== Calculadora de IMC ===\n");

    let peso = ler_numero("Peso (kg): ", 20.0, 300.0);
    let altura = ler_numero("Altura (m): ", 0.5, 2.5);

    let imc = peso / (altura * altura);

    let classificacao = match imc {
        x if x < 18.5 => "Abaixo do peso",
        x if x < 25.0 => "Peso normal",
        x if x < 30.0 => "Sobrepeso",
        _ => "Obesidade",
    };

    println!("\nResultado:");
    println!("  IMC: {:.1}", imc);
    println!("  Classificação: {}", classificacao);

    let continuar = ler_opcao("\nDeseja calcular novamente?", &["sim", "nao"]);
    if continuar == "sim" {
        println!("(Reinicie o programa para calcular novamente)");
    } else {
        println!("Até mais!");
    }
}

use std::io;
use std::io::Write;

struct ListaTarefas {
    tarefas: Vec<(String, bool)>,
}

impl ListaTarefas {
    fn new() -> Self {
        ListaTarefas { tarefas: Vec::new() }
    }

    fn adicionar(&mut self, tarefa: String) {
        self.tarefas.push((tarefa, false));
        println!("Tarefa adicionada! Total: {}", self.tarefas.len());
    }

    fn listar(&self) {
        if self.tarefas.is_empty() {
            println!("Nenhuma tarefa cadastrada.");
            return;
        }
        println!("\n--- Tarefas ---");
        for (i, (tarefa, concluida)) in self.tarefas.iter().enumerate() {
            let status = if *concluida { "[x]" } else { "[ ]" };
            println!("{} {}. {}", status, i + 1, tarefa);
        }
        println!();
    }

    fn concluir(&mut self, indice: usize) {
        if indice > 0 && indice <= self.tarefas.len() {
            self.tarefas[indice - 1].1 = true;
            println!("Tarefa '{}' concluída!", self.tarefas[indice - 1].0);
        } else {
            println!("Índice inválido!");
        }
    }
}

fn ler_comando() -> String {
    print!("> ");
    io::stdout().flush().unwrap();
    let mut entrada = String::new();
    io::stdin().read_line(&mut entrada).unwrap();
    entrada.trim().to_string()
}

fn main() {
    let mut lista = ListaTarefas::new();

    println!("=== Gerenciador de Tarefas ===");
    println!("Comandos: add <tarefa>, list, done <num>, quit\n");

    loop {
        let entrada = ler_comando();
        let partes: Vec<&str> = entrada.splitn(2, ' ').collect();

        match partes[0] {
            "add" | "a" => {
                if partes.len() > 1 {
                    lista.adicionar(partes[1].to_string());
                } else {
                    println!("Uso: add <descrição da tarefa>");
                }
            }
            "list" | "l" => lista.listar(),
            "done" | "d" => {
                if let Some(num) = partes.get(1).and_then(|s| s.parse::<usize>().ok()) {
                    lista.concluir(num);
                } else {
                    println!("Uso: done <número>");
                }
            }
            "quit" | "q" => {
                println!("Até mais!");
                break;
            }
            "" => continue,
            _ => println!("Comando desconhecido: '{}'. Use: add, list, done, quit", partes[0]),
        }
    }
}

[dependencies]
rpassword = "7"

use std::io;
use std::io::Write;

fn main() {
    print!("Usuário: ");
    io::stdout().flush().unwrap();
    let mut usuario = String::new();
    io::stdin().read_line(&mut usuario).unwrap();
    let usuario = usuario.trim();

    let senha = rpassword::prompt_password("Senha: ").unwrap();

    // Validar (exemplo simples)
    if usuario == "admin" && senha == "rust123" {
        println!("Login realizado com sucesso!");
    } else {
        println!("Usuário ou senha incorretos.");
    }
}