ssh-cli 0.2.1

//! Único módulo autorizado a emitir output em stdout para CRUD de VPS.
//!
//! Este módulo centraliza TODA formatação de CRUD: texto e JSON.
//!
//! Logs (tracing) vão para stderr, gerenciados por `tracing-subscriber`.

use crate::mascaramento::mascarar;
use crate::ssh::SaidaExecucao;
use crate::vps::modelo::VpsRegistro;
use secrecy::ExposeSecret;
use serde_json::json;
use std::io::{self, Write};

/// Escreve uma linha em stdout garantindo LF puro (nunca CRLF).
///
/// # Erros
/// Retorna erro se o I/O em stdout falhar.
pub fn escrever_linha(conteudo: &str) -> io::Result<()> {
    let stdout = io::stdout();
    let mut handle = stdout.lock();
    handle.write_all(conteudo.as_bytes())?;
    handle.write_all(b"\n")?;
    handle.flush()?;
    Ok(())
}

/// Imprime mensagem de sucesso em texto para humanos.
pub fn imprimir_sucesso(mensagem: &str) {
    println!("{mensagem}");
}

/// Imprime mensagem de erro em stderr (para humanos).
pub fn imprimir_erro(mensagem: &str) {
    eprintln!("{mensagem}");
}

/// Imprime lista de VPS em formato texto (mascarado).
pub fn imprimir_lista_texto(registros: &[VpsRegistro]) {
    if registros.is_empty() {
        println!(
            "{}",
            crate::i18n::t(crate::i18n::Mensagem::VpsRegistroVazio)
        );
        return;
    }

    println!(
        "{:<20} {:<30} {:<6} {:<15} {:<20}",
        "NOME", "HOST", "PORTA", "USUÁRIO", "SENHA"
    );
    for r in registros {
        println!(
            "{:<20} {:<30} {:<6} {:<15} {:<20}",
            r.nome,
            r.host,
            r.porta,
            r.usuario,
            mascarar(r.senha.expose_secret())
        );
    }
}

/// Imprime lista de VPS em formato JSON (mascarado).
pub fn imprimir_lista_json(registros: &[VpsRegistro]) {
    let lista: Vec<_> = registros.iter().map(registro_para_json_mascarado).collect();
    match serde_json::to_string_pretty(&lista) {
        Ok(s) => println!("{s}"),
        Err(erro) => eprintln!("erro ao serializar JSON: {erro}"),
    }
}

/// Imprime detalhes de UMA VPS em texto (mascarado).
pub fn imprimir_detalhes_texto(r: &VpsRegistro) {
    println!("Nome:           {}", r.nome);
    println!("Host:           {}", r.host);
    println!("Porta:          {}", r.porta);
    println!("Usuário:        {}", r.usuario);
    println!("Senha:          {}", mascarar(r.senha.expose_secret()));
    println!(
        "Senha sudo:     {}",
        r.senha_sudo
            .as_ref()
            .map_or_else(|| "(não definida)".into(), |s| mascarar(s.expose_secret()))
    );
    println!(
        "Senha su:       {}",
        r.senha_su
            .as_ref()
            .map_or_else(|| "(não definida)".into(), |s| mascarar(s.expose_secret()))
    );
    println!("Timeout (ms):   {}", r.timeout_ms);
    println!("Max chars:      {}", r.max_chars);
    println!("Schema version: {}", r.schema_version);
    println!("Adicionado em:  {}", r.adicionado_em);
}

/// Imprime detalhes de UMA VPS em JSON (mascarado).
pub fn imprimir_detalhes_json(r: &VpsRegistro) {
    let v = registro_para_json_mascarado(r);
    match serde_json::to_string_pretty(&v) {
        Ok(s) => println!("{s}"),
        Err(erro) => eprintln!("erro ao serializar JSON: {erro}"),
    }
}

fn registro_para_json_mascarado(r: &VpsRegistro) -> serde_json::Value {
    json!({
        "name": r.nome,
        "host": r.host,
        "port": r.porta,
        "user": r.usuario,
        "password": mascarar(r.senha.expose_secret()),
        "sudo_password": r.senha_sudo.as_ref().map(|s| mascarar(s.expose_secret())),
        "su_password": r.senha_su.as_ref().map(|s| mascarar(s.expose_secret())),
        "timeout_ms": r.timeout_ms,
        "max_chars": r.max_chars,
        "schema_version": r.schema_version,
        "added_at": r.adicionado_em,
    })
}

/// Imprime stdout/stderr de execução de comando SSH.
///
/// Formato:
/// ```text
/// --- stdout ---
/// <stdout>
/// --- stderr ---
/// <stderr>
/// --- exit code: <code> (<duracao_ms>ms) ---
/// ```
pub fn imprimir_saida_execucao(saida: &SaidaExecucao) {
    println!("--- stdout ---");
    if saida.stdout.is_empty() {
        println!("(vazio)");
    } else {
        println!("{}", saida.stdout);
    }
    println!("--- stderr ---");
    if saida.stderr.is_empty() {
        println!("(vazio)");
    } else {
        println!("{}", saida.stderr);
    }
    let code_str = saida
        .exit_code
        .map(|c| c.to_string())
        .unwrap_or_else(|| "N/A".to_string());
    println!("--- exit code: {} ({}ms) ---", code_str, saida.duracao_ms);
    if saida.truncado_stdout {
        println!("(stdout foi truncado)");
    }
    if saida.truncado_stderr {
        println!("(stderr foi truncado)");
    }
}

/// Imprime stdout/stderr de execução de comando SSH em formato JSON.
pub fn imprimir_saida_execucao_json(saida: &SaidaExecucao) {
    let v = json!({
        "stdout": saida.stdout,
        "stderr": saida.stderr,
        "exit_code": saida.exit_code,
        "truncated_stdout": saida.truncado_stdout,
        "truncated_stderr": saida.truncado_stderr,
        "duration_ms": saida.duracao_ms,
    });
    match serde_json::to_string_pretty(&v) {
        Ok(s) => println!("{s}"),
        Err(e) => eprintln!("erro ao serializar JSON: {e}"),
    }
}

/// Imprime resultado de health-check em formato texto.
pub fn imprimir_health_check(nome: &str, latencia_ms: u64) {
    println!(
        "{}",
        crate::i18n::t(crate::i18n::Mensagem::HealthCheckOk {
            nome: nome.to_string(),
        })
    );
    println!("  latência: {latencia_ms}ms");
}

/// Imprime resultado de health-check em formato JSON.
pub fn imprimir_health_check_json(nome: &str, latencia_ms: u64) {
    let v = json!({
        "name": nome,
        "status": "ok",
        "latency_ms": latencia_ms,
    });
    match serde_json::to_string_pretty(&v) {
        Ok(s) => println!("{s}"),
        Err(e) => eprintln!("erro ao serializar JSON: {e}"),
    }
}

#[cfg(test)]
mod testes {
    use super::*;
    use crate::ssh::SaidaExecucao;
    use crate::vps::modelo::VpsRegistro;
    use secrecy::SecretString;

    fn registro_teste() -> VpsRegistro {
        VpsRegistro::novo(
            "vps-teste".into(),
            "1.2.3.4".into(),
            22,
            "root".into(),
            SecretString::from("senha-super-secreta".to_string()),
            Some(5000),
            Some(1000),
            Some(SecretString::from("sudo-password-longa-aqui".to_string())),
            None,
        )
    }

    #[test]
    fn registro_para_json_mascarado_contem_campos_obrigatorios() {
        let r = registro_teste();
        let json = registro_para_json_mascarado(&r);
        assert_eq!(json["name"], "vps-teste");
        assert_eq!(json["host"], "1.2.3.4");
        assert_eq!(json["port"], 22);
        assert_eq!(json["user"], "root");
        assert!(json["password"].as_str().unwrap().contains("..."));
        assert!(json["sudo_password"].as_str().unwrap().contains("..."));
        assert!(json["su_password"].is_null());
        assert_eq!(json["timeout_ms"], 5000);
        assert_eq!(json["max_chars"], 1000);
        assert_eq!(json["schema_version"], 1);
    }

    #[test]
    fn registro_para_json_mascarado_senha_sudo_nula_quando_nao_definida() {
        let mut r = registro_teste();
        r.senha_sudo = None;
        let json = registro_para_json_mascarado(&r);
        assert!(json["sudo_password"].is_null());
    }

    #[test]
    fn registro_para_json_mascarado_su_password_presente() {
        let mut r = registro_teste();
        r.senha_su = Some(SecretString::from("senha-su-muito-longa-aqui".to_string()));
        let json = registro_para_json_mascarado(&r);
        assert!(json["su_password"].as_str().unwrap().contains("..."));
    }

    #[test]
    fn escribir_linha_ok() {
        let resultado = escrever_linha("teste de escrita");
        assert!(resultado.is_ok());
    }

    #[test]
    fn escribir_linha_com_caracteres_especiais() {
        let resultado = escrever_linha("linha com \t tab e \"aspas\"");
        assert!(resultado.is_ok());
    }

    #[test]
    fn salida_execucao_completa_formatada() {
        let saida = SaidaExecucao {
            stdout: "output do comando".to_string(),
            stderr: "erro do comando".to_string(),
            exit_code: Some(0),
            truncado_stdout: false,
            truncado_stderr: false,
            duracao_ms: 150,
        };
        let resultado = escrever_linha(&format!(
            "stdout: {}, stderr: {}, exit: {:?}",
            saida.stdout, saida.stderr, saida.exit_code
        ));
        assert!(resultado.is_ok());
    }

    #[test]
    fn salida_execucao_sem_exit_code() {
        let saida = SaidaExecucao {
            stdout: "".to_string(),
            stderr: "".to_string(),
            exit_code: None,
            truncado_stdout: false,
            truncado_stderr: false,
            duracao_ms: 0,
        };
        let code_str = saida
            .exit_code
            .map(|c| c.to_string())
            .unwrap_or_else(|| "N/A".to_string());
        assert_eq!(code_str, "N/A");
    }

    #[test]
    fn vps_registro_debug_nao_expoe_senha() {
        let r = registro_teste();
        let json = registro_para_json_mascarado(&r);
        let json_str = serde_json::to_string(&json).unwrap();
        assert!(!json_str.contains("senha-super-secreta"));
        assert!(!json_str.contains("sudo-password-longa-aqui"));
    }

    #[test]
    fn salida_execucao_truncada_mostra_aviso() {
        let saida = SaidaExecucao {
            stdout: "output".to_string(),
            stderr: "erro".to_string(),
            exit_code: Some(1),
            truncado_stdout: true,
            truncado_stderr: true,
            duracao_ms: 100,
        };
        assert!(saida.truncado_stdout);
        assert!(saida.truncado_stderr);
    }

    #[test]
    fn salida_execucao_com_exit_code_numerico() {
        let saida = SaidaExecucao {
            stdout: "".to_string(),
            stderr: "".to_string(),
            exit_code: Some(127),
            truncado_stdout: false,
            truncado_stderr: false,
            duracao_ms: 0,
        };
        let code_str = saida
            .exit_code
            .map(|c| c.to_string())
            .unwrap_or_else(|| "N/A".to_string());
        assert_eq!(code_str, "127");
    }

    #[test]
    fn escribir_linha_string_vazia() {
        let resultado = escrever_linha("");
        assert!(resultado.is_ok());
    }

    #[test]
    fn escribir_linha_com_unicode_brasileiro() {
        let resultado = escrever_linha("ação você está Itaú");
        assert!(resultado.is_ok());
    }

    #[test]
    fn escribir_linha_com_emojis() {
        let resultado = escrever_linha("texto com 🚀 e 🔐");
        assert!(resultado.is_ok());
    }

    #[test]
    fn escribir_linha_com_newlines() {
        let resultado = escrever_linha("linha1\nlinha2\nlinha3");
        assert!(resultado.is_ok());
    }

    #[test]
    fn escribir_linha_longo_texto() {
        let texto_longo = "a".repeat(10000);
        let resultado = escrever_linha(&texto_longo);
        assert!(resultado.is_ok());
    }

    #[test]
    fn registro_para_json_mascarado_com_senha_curta_mascara_com_asteriscos() {
        let mut r = registro_teste();
        r.senha = SecretString::from("curta".to_string());
        let json = registro_para_json_mascarado(&r);
        let senha_str = json["password"].as_str().unwrap();
        assert_eq!(senha_str, "***");
    }

    #[test]
    fn registro_para_json_mascarado_com_sudo_e_su_definidos() {
        let mut r = registro_teste();
        r.senha_sudo = Some(SecretString::from("sudo-pass-longa-aqui".to_string()));
        r.senha_su = Some(SecretString::from("su-pass-longa-aqui".to_string()));
        let json = registro_para_json_mascarado(&r);
        assert!(!json["sudo_password"].is_null());
        assert!(!json["su_password"].is_null());
        assert!(json["sudo_password"].as_str().unwrap().contains("..."));
        assert!(json["su_password"].as_str().unwrap().contains("..."));
    }

    #[test]
    fn saida_execucao_formatacao_completa() {
        let saida = SaidaExecucao {
            stdout: "comando executado".to_string(),
            stderr: "aviso harmless".to_string(),
            exit_code: Some(0),
            truncado_stdout: false,
            truncado_stderr: false,
            duracao_ms: 1000,
        };
        assert_eq!(saida.stdout, "comando executado");
        assert_eq!(saida.stderr, "aviso harmless");
        assert_eq!(saida.exit_code, Some(0));
        assert_eq!(saida.duracao_ms, 1000);
        assert!(!saida.truncado_stdout);
        assert!(!saida.truncado_stderr);
    }

    #[test]
    fn saida_execucao_sem_stderr() {
        let saida = SaidaExecucao {
            stdout: "ok".to_string(),
            stderr: String::new(),
            exit_code: Some(0),
            truncado_stdout: false,
            truncado_stderr: false,
            duracao_ms: 50,
        };
        assert!(saida.stderr.is_empty());
    }

    #[test]
    fn saida_execucao_com_sinal_em_vez_de_exit_code() {
        let saida = SaidaExecucao {
            stdout: String::new(),
            stderr: "signal received".to_string(),
            exit_code: None,
            truncado_stdout: false,
            truncado_stderr: false,
            duracao_ms: 5000,
        };
        assert!(saida.exit_code.is_none());
    }

    #[test]
    fn saida_execucao_json_contem_campos_obrigatorios() {
        let saida = SaidaExecucao {
            stdout: "output".to_string(),
            stderr: "erro".to_string(),
            exit_code: Some(0),
            truncado_stdout: false,
            truncado_stderr: false,
            duracao_ms: 100,
        };
        imprimir_saida_execucao_json(&saida);
    }
}