use std::fs;

fn main() {
    // Cria o arquivo (ou sobrescreve se existir)
    fs::write("saida.txt", "Olá, Rust!\nSegunda linha.\n")
        .expect("Erro ao escrever arquivo");

    println!("Arquivo criado com sucesso!");

    // Verificar o conteúdo
    let conteudo = fs::read_to_string("saida.txt").unwrap();
    println!("Conteúdo:\n{}", conteudo);
}

use std::fs::File;
use std::io::{self, Write};

fn main() -> io::Result<()> {
    let mut arquivo = File::create("relatorio.txt")?;

    writeln!(arquivo, "=== Relatório ===")?;
    writeln!(arquivo, "Data: 2026-02-23")?;
    writeln!(arquivo)?; // linha em branco

    // Escrever dados formatados
    let itens = vec![
        ("Notebook", 3, 4599.90),
        ("Mouse", 15, 89.99),
        ("Teclado", 8, 249.50),
    ];

    writeln!(arquivo, "{:<15} {:>5} {:>10}", "Produto", "Qtd", "Preço")?;
    writeln!(arquivo, "{}", "-".repeat(32))?;

    let mut total = 0.0;
    for (nome, qtd, preco) in &itens {
        let subtotal = *qtd as f64 * preco;
        writeln!(arquivo, "{:<15} {:>5} {:>10.2}", nome, qtd, subtotal)?;
        total += subtotal;
    }

    writeln!(arquivo, "{}", "-".repeat(32))?;
    writeln!(arquivo, "{:<15} {:>5} {:>10.2}", "TOTAL", "", total)?;

    println!("Relatório gerado em relatorio.txt");

    // Mostrar resultado
    let conteudo = std::fs::read_to_string("relatorio.txt")?;
    println!("\n{}", conteudo);

    Ok(())
}

use std::fs::File;
use std::io::{self, BufWriter, Write};

fn main() -> io::Result<()> {
    let arquivo = File::create("dados_grandes.txt")?;
    let mut escritor = BufWriter::new(arquivo);

    // Escrever muitas linhas — BufWriter acumula em buffer
    for i in 1..=10_000 {
        writeln!(escritor, "Linha {}: dado_{}", i, i * 7)?;
    }

    // O flush é automático quando BufWriter sai de escopo,
    // mas você pode forçar:
    escritor.flush()?;

    println!("Escritas 10.000 linhas com BufWriter");

    // BufWriter com tamanho de buffer personalizado
    let arquivo = File::create("custom_buffer.txt")?;
    let mut escritor = BufWriter::with_capacity(64 * 1024, arquivo); // 64KB

    for i in 1..=1000 {
        writeln!(escritor, "Entrada {}: valor={:.4}", i, i as f64 * 0.001)?;
    }

    escritor.flush()?;
    println!("Escritas 1.000 linhas com buffer de 64KB");

    Ok(())
}

use std::fs::{self, OpenOptions};
use std::io::{self, Write};

fn adicionar_log(mensagem: &str) -> io::Result<()> {
    let mut arquivo = OpenOptions::new()
        .create(true)    // cria se não existir
        .append(true)    // adiciona ao final
        .open("app.log")?;

    writeln!(arquivo, "[2026-02-23 10:30:00] {}", mensagem)?;
    Ok(())
}

fn main() -> io::Result<()> {
    // Criar arquivo inicial
    fs::write("app.log", "")?;

    // Adicionar várias entradas
    adicionar_log("Aplicação iniciada")?;
    adicionar_log("Conexão com banco estabelecida")?;
    adicionar_log("Servidor escutando na porta 8080")?;
    adicionar_log("Primeira requisição recebida")?;

    // Mostrar resultado
    let conteudo = fs::read_to_string("app.log")?;
    println!("Conteúdo do log:\n{}", conteudo);

    Ok(())
}

use std::fs::File;
use std::io::{self, Write};

fn main() -> io::Result<()> {
    // Escrever bytes diretamente
    let dados: Vec<u8> = (0..=255).collect();
    fs::write("binario.dat", &dados)?;
    println!("Escritos {} bytes em binario.dat", dados.len());

    // Escrever struct como bytes
    let mut arquivo = File::create("numeros.bin")?;
    let numeros: Vec<f64> = vec![3.14, 2.71, 1.41, 1.73];
    for num in &numeros {
        arquivo.write_all(&num.to_le_bytes())?;
    }
    println!("Escritos {} f64 em numeros.bin", numeros.len());

    Ok(())
}

use std::fs;
use std::io::{self, Write};
use std::path::Path;

fn escrever_com_diretorios(caminho: &str, conteudo: &str) -> io::Result<()> {
    // Criar diretórios intermediários se necessário
    if let Some(pai) = Path::new(caminho).parent() {
        fs::create_dir_all(pai)?;
    }
    fs::write(caminho, conteudo)
}

fn main() -> io::Result<()> {
    escrever_com_diretorios(
        "saida/logs/2026/02/app.log",
        "Log de exemplo\n",
    )?;
    println!("Arquivo criado com diretórios intermediários");

    Ok(())
}