Carreira em DevOps e Cloud Native com Rust

use clap::Parser;
use colored::Colorize;
use indicatif::{ProgressBar, ProgressStyle};
use std::fs;
use std::path::PathBuf;
use walkdir::WalkDir;

/// Ferramenta para analisar uso de disco com saída colorida
#[derive(Parser, Debug)]
#[command(name = "disk-analyzer", version, about)]
struct Args {
    /// Diretório para analisar
    #[arg(default_value = ".")]
    caminho: PathBuf,

    /// Profundidade máxima de busca
    #[arg(short, long, default_value_t = 3)]
    profundidade: usize,

    /// Tamanho mínimo para exibir (em bytes)
    #[arg(short, long, default_value_t = 1_048_576)]
    min_tamanho: u64,

    /// Ordenar por tamanho (maior primeiro)
    #[arg(short, long)]
    ordenar: bool,

    /// Formato de saída (texto, json)
    #[arg(short, long, default_value = "texto")]
    formato: String,
}

#[derive(Debug, serde::Serialize)]
struct EntradaDisco {
    caminho: String,
    tamanho_bytes: u64,
    tamanho_legivel: String,
    tipo: String,
}

fn formatar_tamanho(bytes: u64) -> String {
    const KB: u64 = 1024;
    const MB: u64 = 1024 * KB;
    const GB: u64 = 1024 * MB;
    const TB: u64 = 1024 * GB;

    if bytes >= TB {
        format!("{:.2} TB", bytes as f64 / TB as f64)
    } else if bytes >= GB {
        format!("{:.2} GB", bytes as f64 / GB as f64)
    } else if bytes >= MB {
        format!("{:.2} MB", bytes as f64 / MB as f64)
    } else if bytes >= KB {
        format!("{:.2} KB", bytes as f64 / KB as f64)
    } else {
        format!("{} B", bytes)
    }
}

fn analisar_diretorio(args: &Args) -> Vec<EntradaDisco> {
    let spinner = ProgressBar::new_spinner();
    spinner.set_style(
        ProgressStyle::default_spinner()
            .template("{spinner:.green} {msg}")
            .unwrap(),
    );
    spinner.set_message("Analisando diretório...");

    let mut entradas: Vec<EntradaDisco> = Vec::new();

    for entrada in WalkDir::new(&args.caminho)
        .max_depth(args.profundidade)
        .into_iter()
        .filter_map(|e| e.ok())
    {
        spinner.tick();
        let metadata = match entrada.metadata() {
            Ok(m) => m,
            Err(_) => continue,
        };

        let tamanho = if metadata.is_dir() {
            calcular_tamanho_dir(entrada.path())
        } else {
            metadata.len()
        };

        if tamanho >= args.min_tamanho {
            entradas.push(EntradaDisco {
                caminho: entrada.path().display().to_string(),
                tamanho_bytes: tamanho,
                tamanho_legivel: formatar_tamanho(tamanho),
                tipo: if metadata.is_dir() {
                    "diretório".to_string()
                } else {
                    "arquivo".to_string()
                },
            });
        }
    }

    spinner.finish_with_message("Análise concluída!");

    if args.ordenar {
        entradas.sort_by(|a, b| b.tamanho_bytes.cmp(&a.tamanho_bytes));
    }

    entradas
}

fn calcular_tamanho_dir(caminho: &std::path::Path) -> u64 {
    WalkDir::new(caminho)
        .into_iter()
        .filter_map(|e| e.ok())
        .filter_map(|e| e.metadata().ok())
        .filter(|m| m.is_file())
        .map(|m| m.len())
        .sum()
}

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

    match args.formato.as_str() {
        "json" => {
            let json = serde_json::to_string_pretty(&entradas).unwrap();
            println!("{}", json);
        }
        _ => {
            println!(
                "\n{}\n",
                "=== Análise de Uso de Disco ===".bold().cyan()
            );
            for entrada in &entradas {
                let tamanho = format!("{:>10}", entrada.tamanho_legivel);
                let linha = if entrada.tipo == "diretório" {
                    format!(
                        "{} {} {}",
                        tamanho.yellow(),
                        "[DIR]".blue(),
                        entrada.caminho.bold()
                    )
                } else {
                    format!(
                        "{} {} {}",
                        tamanho.green(),
                        "[ARQ]".white(),
                        entrada.caminho
                    )
                };
                println!("{}", linha);
            }
            println!(
                "\nTotal de entradas: {}",
                entradas.len().to_string().bold()
            );
        }
    }
}

use std::process::Command;
use std::collections::HashMap;
use serde::{Deserialize, Serialize};

/// Configuração de deploy
#[derive(Debug, Deserialize)]
struct DeployConfig {
    projeto: String,
    ambiente: String,
    imagem_docker: String,
    replicas: u32,
    variaveis_ambiente: HashMap<String, String>,
    health_check: HealthCheck,
}

#[derive(Debug, Deserialize)]
struct HealthCheck {
    endpoint: String,
    intervalo_seg: u32,
    timeout_seg: u32,
    tentativas: u32,
}

#[derive(Debug, Serialize)]
struct DeployResult {
    sucesso: bool,
    mensagem: String,
    versao: String,
    tempo_total_seg: f64,
}

struct DeployPipeline {
    config: DeployConfig,
}

impl DeployPipeline {
    fn new(config: DeployConfig) -> Self {
        DeployPipeline { config }
    }

    fn executar_etapa(
        &self,
        nome: &str,
        comando: &str,
        args: &[&str],
    ) -> Result<String, String> {
        println!("  [{}] Executando: {} {}", nome, comando, args.join(" "));

        let output = Command::new(comando)
            .args(args)
            .output()
            .map_err(|e| format!("Falha ao executar {}: {}", comando, e))?;

        if output.status.success() {
            let stdout = String::from_utf8_lossy(&output.stdout).to_string();
            println!("  [{}] Sucesso", nome);
            Ok(stdout)
        } else {
            let stderr = String::from_utf8_lossy(&output.stderr).to_string();
            Err(format!("Etapa '{}' falhou: {}", nome, stderr))
        }
    }

    fn construir_imagem(&self) -> Result<String, String> {
        println!("\n--- Etapa 1: Build da Imagem Docker ---");

        self.executar_etapa(
            "build",
            "docker",
            &[
                "build",
                "-t",
                &self.config.imagem_docker,
                "--build-arg",
                &format!("AMBIENTE={}", self.config.ambiente),
                ".",
            ],
        )
    }

    fn executar_testes(&self) -> Result<String, String> {
        println!("\n--- Etapa 2: Testes ---");

        self.executar_etapa(
            "test",
            "cargo",
            &["test", "--release", "--", "--nocapture"],
        )
    }

    fn push_imagem(&self) -> Result<String, String> {
        println!("\n--- Etapa 3: Push da Imagem ---");

        self.executar_etapa(
            "push",
            "docker",
            &["push", &self.config.imagem_docker],
        )
    }

    fn aplicar_deploy(&self) -> Result<String, String> {
        println!("\n--- Etapa 4: Deploy ---");

        self.executar_etapa(
            "deploy",
            "kubectl",
            &[
                "set",
                "image",
                &format!("deployment/{}", self.config.projeto),
                &format!(
                    "{}={}",
                    self.config.projeto, self.config.imagem_docker
                ),
                "--namespace",
                &self.config.ambiente,
            ],
        )
    }

    fn verificar_health(&self) -> Result<String, String> {
        println!("\n--- Etapa 5: Health Check ---");

        for tentativa in 1..=self.config.health_check.tentativas {
            println!(
                "  Tentativa {}/{}...",
                tentativa, self.config.health_check.tentativas
            );

            let resultado = self.executar_etapa(
                "health",
                "curl",
                &[
                    "-sf",
                    "--max-time",
                    &self.config.health_check.timeout_seg.to_string(),
                    &self.config.health_check.endpoint,
                ],
            );

            if resultado.is_ok() {
                return resultado;
            }

            std::thread::sleep(std::time::Duration::from_secs(
                self.config.health_check.intervalo_seg as u64,
            ));
        }

        Err("Health check falhou após todas as tentativas".to_string())
    }

    fn executar(&self) -> DeployResult {
        let inicio = std::time::Instant::now();

        let resultado = (|| -> Result<(), String> {
            self.construir_imagem()?;
            self.executar_testes()?;
            self.push_imagem()?;
            self.aplicar_deploy()?;
            self.verificar_health()?;
            Ok(())
        })();

        let tempo_total = inicio.elapsed().as_secs_f64();

        match resultado {
            Ok(()) => DeployResult {
                sucesso: true,
                mensagem: format!(
                    "Deploy de '{}' no ambiente '{}' concluído com sucesso!",
                    self.config.projeto, self.config.ambiente
                ),
                versao: self.config.imagem_docker.clone(),
                tempo_total_seg: tempo_total,
            },
            Err(e) => DeployResult {
                sucesso: false,
                mensagem: format!("Deploy falhou: {}", e),
                versao: self.config.imagem_docker.clone(),
                tempo_total_seg: tempo_total,
            },
        }
    }
}

use std::collections::HashMap;
use std::time::{Duration, Instant, SystemTime};

/// Sistema de métricas simples para monitoramento
struct MetricsCollector {
    counters: HashMap<String, u64>,
    gauges: HashMap<String, f64>,
    histograms: HashMap<String, Vec<f64>>,
}

impl MetricsCollector {
    fn new() -> Self {
        MetricsCollector {
            counters: HashMap::new(),
            gauges: HashMap::new(),
            histograms: HashMap::new(),
        }
    }

    /// Incrementa um contador
    fn increment(&mut self, nome: &str, valor: u64) {
        *self.counters.entry(nome.to_string()).or_insert(0) += valor;
    }

    /// Define o valor de um gauge
    fn set_gauge(&mut self, nome: &str, valor: f64) {
        self.gauges.insert(nome.to_string(), valor);
    }

    /// Adiciona uma observação ao histograma
    fn observe(&mut self, nome: &str, valor: f64) {
        self.histograms
            .entry(nome.to_string())
            .or_insert_with(Vec::new)
            .push(valor);
    }

    /// Calcula percentil para um histograma
    fn percentil(&self, nome: &str, p: f64) -> Option<f64> {
        self.histograms.get(nome).map(|valores| {
            let mut sorted = valores.clone();
            sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());
            let idx = ((p / 100.0) * sorted.len() as f64) as usize;
            sorted[idx.min(sorted.len() - 1)]
        })
    }

    /// Exporta métricas no formato Prometheus
    fn exportar_prometheus(&self) -> String {
        let mut output = String::new();

        for (nome, valor) in &self.counters {
            output.push_str(&format!(
                "# TYPE {} counter\n{} {}\n",
                nome, nome, valor
            ));
        }

        for (nome, valor) in &self.gauges {
            output.push_str(&format!(
                "# TYPE {} gauge\n{} {}\n",
                nome, nome, valor
            ));
        }

        for (nome, valores) in &self.histograms {
            let soma: f64 = valores.iter().sum();
            let count = valores.len();
            output.push_str(&format!(
                "# TYPE {} summary\n{}_sum {}\n{}_count {}\n",
                nome, nome, soma, nome, count
            ));

            // Percentis comuns
            for p in &[50.0, 90.0, 95.0, 99.0] {
                if let Some(val) = self.percentil(nome, *p) {
                    output.push_str(&format!(
                        "{}{{quantile=\"{}\"}} {:.6}\n",
                        nome,
                        p / 100.0,
                        val
                    ));
                }
            }
        }

        output
    }
}

/// Health checker para serviços
struct HealthChecker {
    servicos: Vec<ServiceCheck>,
}

struct ServiceCheck {
    nome: String,
    url: String,
    timeout: Duration,
}

#[derive(Debug, serde::Serialize)]
struct HealthStatus {
    nome: String,
    status: String,
    latencia_ms: f64,
    mensagem: String,
}

impl HealthChecker {
    fn new() -> Self {
        HealthChecker {
            servicos: Vec::new(),
        }
    }

    fn adicionar_servico(
        &mut self,
        nome: &str,
        url: &str,
        timeout: Duration,
    ) {
        self.servicos.push(ServiceCheck {
            nome: nome.to_string(),
            url: url.to_string(),
            timeout,
        });
    }

    fn verificar_todos(&self) -> Vec<HealthStatus> {
        self.servicos
            .iter()
            .map(|servico| {
                let inicio = Instant::now();
                // Simulação de verificação HTTP
                let latencia = inicio.elapsed();

                HealthStatus {
                    nome: servico.nome.clone(),
                    status: "healthy".to_string(),
                    latencia_ms: latencia.as_secs_f64() * 1000.0,
                    mensagem: "OK".to_string(),
                }
            })
            .collect()
    }
}

fn main() {
    // Exemplo de uso do coletor de métricas
    let mut metrics = MetricsCollector::new();

    metrics.increment("http_requests_total", 1);
    metrics.increment("http_requests_total", 1);
    metrics.set_gauge("memory_usage_bytes", 1_048_576.0);
    metrics.observe("http_request_duration_seconds", 0.045);
    metrics.observe("http_request_duration_seconds", 0.120);
    metrics.observe("http_request_duration_seconds", 0.008);

    println!("=== Métricas Prometheus ===\n");
    println!("{}", metrics.exportar_prometheus());

    // Health checker
    let mut checker = HealthChecker::new();
    checker.adicionar_servico(
        "api",
        "http://localhost:3000/health",
        Duration::from_secs(5),
    );
    checker.adicionar_servico(
        "banco",
        "http://localhost:5432",
        Duration::from_secs(3),
    );

    let status = checker.verificar_todos();
    println!("=== Health Check ===\n");
    for s in &status {
        println!(
            "  {} - {} ({:.2}ms)",
            s.nome, s.status, s.latencia_ms
        );
    }
}

# === Estágio de build ===
FROM rust:1.76-slim as builder

WORKDIR /app

# Copiar manifesto primeiro para cache de dependências
COPY Cargo.toml Cargo.lock ./

# Criar projeto dummy para compilar dependências
RUN mkdir src && echo "fn main() {}" > src/main.rs
RUN cargo build --release
RUN rm -rf src

# Copiar código real e compilar
COPY src ./src
RUN touch src/main.rs && cargo build --release

# === Estágio de produção ===
FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*

COPY --from=builder /app/target/release/minha-ferramenta /usr/local/bin/

# Usuário não-root
RUN useradd -ms /bin/bash appuser
USER appuser

ENTRYPOINT ["minha-ferramenta"]