Arrays e Vec<T>: Estruturas Contíguas em Rust

fn demonstrar_arrays() {
    // Declaração de array com tipo e tamanho explícitos
    let notas: [f64; 5] = [7.5, 8.0, 9.2, 6.8, 7.0];

    // Array inicializado com valor padrão (todos iguais)
    let zeros: [i32; 10] = [0; 10];

    // Acesso por índice (verificado em tempo de execução)
    let primeira_nota = notas[0];
    println!("Primeira nota: {}", primeira_nota);

    // Iteração com enumerate
    for (i, nota) in notas.iter().enumerate() {
        println!("Aluno {}: {:.1}", i + 1, nota);
    }

    // Tamanho do array
    println!("Total de alunos: {}", notas.len());

    // Slicing — criando uma fatia
    let tres_primeiras = &notas[0..3];
    println!("Três primeiras notas: {:?}", tres_primeiras);

    // Arrays suportam pattern matching
    match notas {
        [primeiro, .., ultimo] => {
            println!("Primeira: {}, Última: {}", primeiro, ultimo);
        }
    }

    // Média usando iteradores
    let soma: f64 = notas.iter().sum();
    let media = soma / notas.len() as f64;
    println!("Média da turma: {:.2}", media);

    println!("Zeros: {:?}", zeros);
}

fn demonstrar_vec() {
    // Criação com macro vec!
    let mut frutas = vec!["maçã", "banana", "laranja"];

    // Criação com capacidade pré-alocada (evita realocações)
    let mut numeros: Vec<i32> = Vec::with_capacity(100);
    println!("Len: {}, Capacidade: {}", numeros.len(), numeros.capacity());

    // Inserção no final — O(1) amortizado
    numeros.push(10);
    numeros.push(20);
    numeros.push(30);

    // Remoção do final — O(1)
    if let Some(ultimo) = numeros.pop() {
        println!("Removido: {}", ultimo); // 30
    }

    // Inserção em posição específica — O(n)
    frutas.insert(1, "manga"); // ["maçã", "manga", "banana", "laranja"]

    // Remoção por índice — O(n)
    let removida = frutas.remove(2); // remove "banana"
    println!("Fruta removida: {}", removida);

    // swap_remove — O(1), mas não preserva ordem
    frutas.push("uva");
    frutas.push("pêra");
    println!("Antes do swap_remove: {:?}", frutas);
    frutas.swap_remove(0); // troca o primeiro pelo último e remove
    println!("Após swap_remove(0): {:?}", frutas);

    // Busca
    if frutas.contains(&"manga") {
        println!("Temos manga!");
    }

    // Encontrar posição
    if let Some(pos) = frutas.iter().position(|&f| f == "uva") {
        println!("Uva está na posição: {}", pos);
    }

    // Ordenação
    let mut valores = vec![42, 17, 93, 5, 28, 61];
    valores.sort(); // ordenação estável
    println!("Ordenado: {:?}", valores);

    // Deduplicação (requer ordenação prévia)
    let mut com_duplicatas = vec![3, 1, 4, 1, 5, 9, 2, 6, 5, 3];
    com_duplicatas.sort();
    com_duplicatas.dedup();
    println!("Sem duplicatas: {:?}", com_duplicatas);

    // Redimensionamento
    let mut buffer = vec![0u8; 10];
    buffer.resize(20, 0xFF); // expande preenchendo com 0xFF
    println!("Buffer: {:?}", buffer);
}

fn demonstrar_iteradores() {
    let numeros = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // map — transformar cada elemento
    let dobrados: Vec<i32> = numeros.iter().map(|&x| x * 2).collect();
    println!("Dobrados: {:?}", dobrados);

    // filter — selecionar elementos
    let pares: Vec<&i32> = numeros.iter().filter(|&&x| x % 2 == 0).collect();
    println!("Pares: {:?}", pares);

    // fold — reduzir a um único valor (soma)
    let soma = numeros.iter().fold(0, |acumulador, &x| acumulador + x);
    println!("Soma: {}", soma);

    // Encadear operações: filtrar pares, dobrar e somar
    let resultado: i32 = numeros
        .iter()
        .filter(|&&x| x % 2 == 0)       // [2, 4, 6, 8, 10]
        .map(|&x| x * 2)                 // [4, 8, 12, 16, 20]
        .sum();                           // 60
    println!("Pares dobrados somados: {}", resultado);

    // chunks — dividir em pedaços
    let dados = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
    for (i, pedaco) in dados.chunks(3).enumerate() {
        println!("Lote {}: {:?}", i, pedaco);
    }

    // windows — janelas deslizantes
    let precos = vec![100, 102, 98, 105, 110, 108];
    println!("Médias móveis (janela 3):");
    for janela in precos.windows(3) {
        let media: f64 = janela.iter().sum::<i32>() as f64 / 3.0;
        println!("  {:?} → média = {:.1}", janela, media);
    }

    // flat_map — achatar estruturas aninhadas
    let frases = vec!["olá mundo", "rust é incrível"];
    let palavras: Vec<&str> = frases.iter().flat_map(|f| f.split_whitespace()).collect();
    println!("Palavras: {:?}", palavras);

    // zip — combinar dois iteradores
    let nomes = vec!["Ana", "Bruno", "Clara"];
    let idades = vec![25, 30, 28];
    let pessoas: Vec<(&str, &i32)> = nomes.iter().zip(idades.iter()).collect();
    println!("Pessoas: {:?}", pessoas);

    // any e all — predicados
    let tem_negativo = numeros.iter().any(|&x| x < 0);
    let todos_positivos = numeros.iter().all(|&x| x > 0);
    println!("Tem negativo? {} | Todos positivos? {}", tem_negativo, todos_positivos);
}

use std::fmt;

/// Representa um registro de venda
#[derive(Debug, Clone)]
struct Venda {
    data: String,
    produto: String,
    categoria: String,
    quantidade: u32,
    preco_unitario: f64,
    regiao: String,
}

impl Venda {
    /// Calcula o valor total da venda
    fn valor_total(&self) -> f64 {
        self.quantidade as f64 * self.preco_unitario
    }
}

/// Relatório de vendas por categoria
#[derive(Debug)]
struct RelatorioCategoria {
    categoria: String,
    total_vendas: f64,
    quantidade_registros: usize,
    ticket_medio: f64,
}

impl fmt::Display for RelatorioCategoria {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "| {:<15} | R$ {:>10.2} | {:>6} registros | Ticket médio: R$ {:>8.2} |",
            self.categoria, self.total_vendas, self.quantidade_registros, self.ticket_medio
        )
    }
}

/// Analisa uma linha CSV e retorna uma Venda
fn parsear_linha_csv(linha: &str) -> Option<Venda> {
    let campos: Vec<&str> = linha.split(',').map(|c| c.trim()).collect();
    if campos.len() != 6 {
        return None;
    }

    Some(Venda {
        data: campos[0].to_string(),
        produto: campos[1].to_string(),
        categoria: campos[2].to_string(),
        quantidade: campos[3].parse().ok()?,
        preco_unitario: campos[4].parse().ok()?,
        regiao: campos[5].to_string(),
    })
}

/// Gera relatório agrupado por categoria usando apenas Vec e iteradores
fn gerar_relatorio_por_categoria(vendas: &[Venda]) -> Vec<RelatorioCategoria> {
    // Coleta todas as categorias únicas
    let mut categorias: Vec<String> = vendas.iter().map(|v| v.categoria.clone()).collect();
    categorias.sort();
    categorias.dedup();

    // Para cada categoria, calcula as métricas
    categorias
        .into_iter()
        .map(|cat| {
            let vendas_categoria: Vec<&Venda> =
                vendas.iter().filter(|v| v.categoria == cat).collect();

            let total: f64 = vendas_categoria.iter().map(|v| v.valor_total()).sum();
            let qtd = vendas_categoria.len();
            let ticket = if qtd > 0 { total / qtd as f64 } else { 0.0 };

            RelatorioCategoria {
                categoria: cat,
                total_vendas: total,
                quantidade_registros: qtd,
                ticket_medio: ticket,
            }
        })
        .collect()
}

/// Encontra os N produtos mais vendidos (por valor total)
fn top_produtos(vendas: &[Venda], n: usize) -> Vec<(String, f64)> {
    // Agrupa por produto
    let mut produtos: Vec<String> = vendas.iter().map(|v| v.produto.clone()).collect();
    produtos.sort();
    produtos.dedup();

    let mut ranking: Vec<(String, f64)> = produtos
        .into_iter()
        .map(|prod| {
            let total: f64 = vendas
                .iter()
                .filter(|v| v.produto == prod)
                .map(|v| v.valor_total())
                .sum();
            (prod, total)
        })
        .collect();

    // Ordena por valor total decrescente
    ranking.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());

    // Retorna apenas os N primeiros
    ranking.into_iter().take(n).collect()
}

fn main() {
    // Simulando dados CSV (em produção, viria de um arquivo)
    let dados_csv = vec![
        "2024-01-15, Notebook Dell, Eletrônicos, 2, 4500.00, Sudeste",
        "2024-01-15, Cadeira Gamer, Móveis, 5, 1200.00, Sul",
        "2024-01-16, Mouse Logitech, Eletrônicos, 15, 150.00, Sudeste",
        "2024-01-16, Mesa Escritório, Móveis, 3, 800.00, Nordeste",
        "2024-01-17, Monitor 27pol, Eletrônicos, 8, 2200.00, Sudeste",
        "2024-01-17, Teclado Mecânico, Eletrônicos, 20, 350.00, Sul",
        "2024-01-18, Sofá 3 Lugares, Móveis, 2, 3500.00, Sudeste",
        "2024-01-18, Webcam HD, Eletrônicos, 12, 280.00, Centro-Oeste",
        "2024-01-19, Estante Livros, Móveis, 4, 650.00, Nordeste",
        "2024-01-19, SSD 1TB, Eletrônicos, 25, 420.00, Sudeste",
        "2024-01-20, Cadeira Gamer, Móveis, 3, 1200.00, Norte",
        "2024-01-20, Notebook Dell, Eletrônicos, 1, 4500.00, Nordeste",
    ];

    // Pipeline de processamento usando iteradores
    let vendas: Vec<Venda> = dados_csv
        .iter()
        .filter_map(|linha| parsear_linha_csv(linha))
        .collect();

    println!("══════════════════════════════════════════════════════");
    println!("           RELATÓRIO DE VENDAS - JANEIRO 2024        ");
    println!("══════════════════════════════════════════════════════\n");

    // Resumo geral
    let total_geral: f64 = vendas.iter().map(|v| v.valor_total()).sum();
    let total_itens: u32 = vendas.iter().map(|v| v.quantidade).sum();
    println!("Total de registros: {}", vendas.len());
    println!("Total de itens vendidos: {}", total_itens);
    println!("Valor total: R$ {:.2}\n", total_geral);

    // Relatório por categoria
    println!("─── Por Categoria ───────────────────────────────────");
    let relatorio = gerar_relatorio_por_categoria(&vendas);
    for r in &relatorio {
        println!("{}", r);
    }

    // Top 5 produtos
    println!("\n─── Top 5 Produtos ──────────────────────────────────");
    for (i, (produto, valor)) in top_produtos(&vendas, 5).iter().enumerate() {
        println!("  {}º  {:<20} R$ {:.2}", i + 1, produto, valor);
    }

    // Vendas por região usando chunks para exibição paginada
    println!("\n─── Vendas por Região (paginado) ────────────────────");
    let vendas_por_pagina = 4;
    for (pagina, grupo) in vendas.chunks(vendas_por_pagina).enumerate() {
        println!("  Página {}:", pagina + 1);
        for v in grupo {
            println!(
                "    {} | {:<20} | {} un. | R$ {:.2}",
                v.data, v.produto, v.quantidade, v.valor_total()
            );
        }
    }

    // Filtro avançado: vendas acima de R$ 5000 na região Sudeste
    println!("\n─── Vendas > R$ 5000 no Sudeste ─────────────────────");
    let grandes_vendas_sudeste: Vec<&Venda> = vendas
        .iter()
        .filter(|v| v.regiao == "Sudeste" && v.valor_total() > 5000.0)
        .collect();

    if grandes_vendas_sudeste.is_empty() {
        println!("  Nenhuma venda encontrada com esses critérios.");
    } else {
        for v in &grandes_vendas_sudeste {
            println!(
                "  {} — {} — R$ {:.2}",
                v.data, v.produto, v.valor_total()
            );
        }
    }
}