fundaia 0.7.2

//! The read-only half of the tool: everything that answers a question.
//!
//! Every one of these prints a table and nothing else. That is a rule rather
//! than a habit — the output of this tool is read by people and by scripts, and
//! a command that also prints a friendly sentence is a command whose second
//! line breaks `awk`.

use anyhow::Result;
use owo_colors::OwoColorize;

use crate::api::client::ApiClient;
use crate::render::pipeline::{epoch_millis, format_millis};
use crate::render::table::{truncate, Cell, Table};
use crate::render::theme;

pub async fn status(client: &ApiClient) -> Result<()> {
    let projects = client.projects().await?;

    let services: u32 = projects.iter().map(|project| project.service_count).sum();
    let online: u32 = projects.iter().map(|project| project.online_count).sum();

    println!();
    println!("  {}", client.base().style(theme::strong()));

    // Best effort, and never fatal. An instance too old to answer `/api/version`
    // is exactly the case this line exists to surface, so failing to read it
    // must not take the rest of the screen down with it.
    if let Ok(version) = client.version().await {
        let mine = env!("CARGO_PKG_VERSION");
        let note = if version.platform == mine {
            String::new()
        } else {
            format!(" · este binario es {mine}")
        };

        println!(
            "  {}{}",
            format!("servidor {}", version.platform).style(theme::muted()),
            note.style(theme::muted()),
        );
    }

    println!(
        "  {} proyectos · {} servicios · {} en marcha",
        projects.len().style(theme::strong()),
        services.style(theme::strong()),
        if online == services && services > 0 {
            format!("{}", online.style(theme::success()))
        } else if online == 0 && services > 0 {
            format!("{}", online.style(theme::danger()))
        } else {
            format!("{}", online.style(theme::warning()))
        },
    );
    println!();

    let mut table = Table::new(&["proyecto", "entorno", "servicios", "estado"]);

    for project in &projects {
        // The dots are the service states in creation order, which is the same
        // order the canvas lays them out — one glance says which one is red.
        let dots: String = project
            .services
            .iter()
            .map(|service| theme::state_dot(&service.state))
            .collect::<Vec<_>>()
            .join(" ");

        table.push(vec![
            Cell::styled(project.name.clone(), theme::strong()),
            Cell::styled(project.environment_name.clone(), theme::muted()),
            Cell::plain(format!(
                "{}/{}",
                project.online_count, project.service_count
            )),
            Cell::plain(dots),
        ]);
    }

    if table.is_empty() {
        println!(
            "  {}",
            "Todavía no hay ningún proyecto.".style(theme::muted())
        );
    } else {
        table.print();
    }
    println!();

    Ok(())
}

pub async fn projects(client: &ApiClient) -> Result<()> {
    let projects = client.projects().await?;
    let mut table = Table::new(&["id", "nombre", "slug", "servicios"]);

    for project in &projects {
        table.push(vec![
            Cell::styled(project.id.clone(), theme::muted()),
            Cell::styled(project.name.clone(), theme::strong()),
            Cell::plain(project.slug.clone()),
            Cell::plain(format!(
                "{}/{}",
                project.online_count, project.service_count
            )),
        ]);
    }

    if table.is_empty() {
        println!("Todavía no hay ningún proyecto.");
        return Ok(());
    }

    table.print();
    Ok(())
}

pub async fn services(client: &ApiClient, project_reference: &str) -> Result<()> {
    let project = client.find_project(project_reference).await?;
    let page = client.services(&project.id).await?;

    let mut table = Table::new(&["servicio", "estado", "origen", "host", "depende de"]);

    for service in &page.services {
        // Named rather than by id: the arrow is for a person, and an id in a
        // dependency column is unreadable next to a name in the first one.
        let dependencies: Vec<String> = page
            .edges
            .iter()
            .filter(|edge| edge.from == service.id)
            .filter_map(|edge| page.services.iter().find(|target| target.id == edge.to))
            .map(|target| target.name.clone())
            .collect();

        table.push(vec![
            Cell::styled(service.name.clone(), theme::strong()),
            Cell::styled(
                format!(
                    "{} {}",
                    theme::state_dot(&service.state),
                    theme::state_word(&service.state)
                ),
                theme::state_style(&service.state),
            ),
            Cell::styled(
                service
                    .repo_full_name
                    .clone()
                    .or_else(|| service.brand.clone())
                    .unwrap_or_else(|| "—".to_owned()),
                theme::muted(),
            ),
            Cell::styled(
                service.host.clone().unwrap_or_else(|| "—".to_owned()),
                theme::muted(),
            ),
            Cell::plain(if dependencies.is_empty() {
                "—".to_owned()
            } else {
                dependencies.join(", ")
            }),
        ]);
    }

    if table.is_empty() {
        println!("`{}` todavía no tiene servicios.", project.name);
        return Ok(());
    }

    table.print();
    Ok(())
}

pub async fn service(
    client: &ApiClient,
    project_reference: &str,
    service_reference: &str,
) -> Result<()> {
    let project = client.find_project(project_reference).await?;
    let found = client.find_service(&project.id, service_reference).await?;
    let detail = client.service_detail(&found.id).await?;

    println!();
    println!(
        "  {} {} {}",
        theme::state_dot(&detail.environment.state),
        detail.service.name.style(theme::strong()),
        theme::state_word(&detail.environment.state)
            .style(theme::state_style(&detail.environment.state)),
    );
    println!(
        "  {} {}",
        "id".style(theme::muted()),
        detail.environment.id.style(theme::muted())
    );
    println!(
        "  {} {} MB · {} CPU · {}",
        "recursos".style(theme::muted()),
        detail.environment.memory_mb,
        detail.environment.cpus,
        if detail.environment.sleep_enabled {
            "duerme sin tráfico"
        } else {
            "siempre despierto"
        },
    );

    // Serving ones only. A summary is read as "where is this", and a hostname
    // that is switched off is not an answer to that.
    for domain in detail.domains.iter().filter(|domain| domain.enabled) {
        println!(
            "  {} {}",
            "host".style(theme::muted()),
            domain.url.style(theme::accent())
        );
    }

    if let Some(deployment) = &detail.active_deployment {
        println!(
            "  {} #{} {}",
            "activo".style(theme::muted()),
            deployment.number,
            deployment
                .commit_subject
                .clone()
                .unwrap_or_else(|| deployment.trigger.clone())
                .style(theme::muted()),
        );
    }

    println!();
    Ok(())
}

pub async fn history(
    client: &ApiClient,
    project_reference: &str,
    service_reference: &str,
    limit: usize,
) -> Result<()> {
    let project = client.find_project(project_reference).await?;
    let found = client.find_service(&project.id, service_reference).await?;
    let deployments = client.deployments(&found.id).await?;

    let mut table = Table::new(&["#", "estado", "motivo", "commit", "duración", "asunto"]);

    for deployment in deployments.iter().take(limit) {
        let duration = match (
            &deployment.finished_at,
            epoch_millis(&deployment.created_at),
        ) {
            (Some(finished), Some(created)) => epoch_millis(finished)
                .map(|end| format_millis(end - created))
                .unwrap_or_else(|| "—".to_owned()),
            _ => "—".to_owned(),
        };

        table.push(vec![
            Cell::plain(format!("{}", deployment.number)),
            Cell::styled(
                deployment.status.clone(),
                theme::deployment_status_style(&deployment.status),
            ),
            Cell::styled(deployment.trigger.clone(), theme::muted()),
            Cell::styled(
                deployment
                    .commit_sha
                    .as_ref()
                    .map(|sha| sha.chars().take(7).collect::<String>())
                    .unwrap_or_else(|| "—".to_owned()),
                theme::muted(),
            ),
            Cell::plain(duration),
            Cell::plain(truncate(
                deployment
                    .failure_message
                    .as_ref()
                    .or(deployment.commit_subject.as_ref())
                    .map(String::as_str)
                    .unwrap_or("—"),
                52,
            )),
        ]);
    }

    if table.is_empty() {
        println!("`{}` no se ha desplegado nunca.", found.name);
        return Ok(());
    }

    table.print();
    Ok(())
}

pub async fn metrics(
    client: &ApiClient,
    project_reference: &str,
    service_reference: &str,
    minutes: u32,
) -> Result<()> {
    let project = client.find_project(project_reference).await?;
    let found = client.find_service(&project.id, service_reference).await?;
    let samples = client.usage(&found.id, minutes).await?;

    let Some(latest) = samples.last() else {
        println!("Todavía no hay medidas de `{}`.", found.name);
        return Ok(());
    };

    // `checked_div` rather than a guard: a limit of zero means the runtime never
    // reported one, and "no percentage" is honestly zero rather than a division
    // somebody has to remember to protect.
    let share = (latest.memory_bytes * 100)
        .checked_div(latest.memory_limit_bytes)
        .unwrap_or(0) as u32;

    println!();
    println!(
        "  {} {} mCPU",
        "cpu    ".style(theme::muted()),
        latest.cpu_millicores.style(theme::strong())
    );
    println!(
        "  {} {} MB de {} MB",
        "memoria".style(theme::muted()),
        (latest.memory_bytes / 1_000_000).style(theme::strong()),
        latest.memory_limit_bytes / 1_000_000,
    );
    println!("  {} {}", "límite ".style(theme::muted()), bar(share));
    println!();

    // The sparkline is the point of asking for a window rather than a reading:
    // one number says how it is, forty say where it is going.
    let cpu: Vec<u64> = samples
        .iter()
        .map(|sample| u64::from(sample.cpu_millicores))
        .collect();
    let memory: Vec<u64> = samples
        .iter()
        .map(|sample| sample.memory_bytes / 1_000_000)
        .collect();

    println!("  {} {}", "cpu    ".style(theme::muted()), sparkline(&cpu));
    println!(
        "  {} {}",
        "memoria".style(theme::muted()),
        sparkline(&memory)
    );
    println!(
        "  {}",
        format!("{} medidas de los últimos {minutes} minutos", samples.len()).style(theme::muted()),
    );
    println!();

    Ok(())
}

/// A meter, in twenty characters.
fn bar(percent: u32) -> String {
    let filled = (percent.min(100) as usize) / 5;
    let style = if percent > 90 {
        theme::danger()
    } else if percent > 70 {
        theme::warning()
    } else {
        theme::success()
    };

    format!(
        "{}{} {percent}%",
        "█".repeat(filled).style(style),
        "░".repeat(20 - filled).style(theme::muted()),
    )
}

/// Braille-free sparkline: eight block heights, scaled to the largest reading.
///
/// Scaled to the window rather than to the limit, because the question a
/// sparkline answers is "is this changing", and a series pinned to the bottom
/// of a 512 MB axis answers nothing.
pub fn sparkline(values: &[u64]) -> String {
    const BLOCKS: [char; 8] = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];

    let Some(highest) = values.iter().copied().max() else {
        return String::new();
    };
    if highest == 0 {
        return BLOCKS[0].to_string().repeat(values.len());
    }

    values
        .iter()
        .map(|value| {
            let index = ((value * 7) / highest) as usize;
            BLOCKS[index.min(7)]
        })
        .collect()
}

pub async fn variables(
    client: &ApiClient,
    project_reference: &str,
    service_reference: &str,
    reveal: bool,
) -> Result<()> {
    let project = client.find_project(project_reference).await?;
    let found = client.find_service(&project.id, service_reference).await?;
    let variables = client.variables(&found.id).await?;

    let mut table = Table::new(&["clave", "tipo", "valor"]);

    for variable in &variables {
        // Revealing is per variable and audited server-side, so it is one call
        // each rather than a bulk endpoint that would log one access for many.
        // A sealed one is skipped rather than attempted: the server would refuse
        // it, and a row of failed requests is a worse way to say "no".
        let value =
            if reveal && variable.kind == "secret" && !variable.write_only && !variable.is_sealed()
            {
                client
                    .reveal_variable(&variable.id)
                    .await
                    .unwrap_or_else(|_| "—".to_owned())
            } else if variable.is_sealed() {
                "sellada · solo se puede borrar".to_owned()
            } else {
                variable
                    .preview
                    .clone()
                    .unwrap_or_else(|| "••••••••".to_owned())
            };

        let kind = if variable.is_sealed() {
            "sellada".to_owned()
        } else {
            variable.kind.clone()
        };

        table.push(vec![
            Cell::styled(variable.key.clone(), theme::strong()),
            Cell::styled(
                kind,
                match (variable.is_sealed(), variable.kind.as_str()) {
                    (true, _) => theme::warning(),
                    (false, "reference") => theme::accent(),
                    (false, "secret") => theme::warning(),
                    _ => theme::muted(),
                },
            ),
            Cell::plain(truncate(&value, 60)),
        ]);
    }

    if table.is_empty() {
        println!("`{}` no define ninguna variable.", found.name);
        return Ok(());
    }

    table.print();
    Ok(())
}

pub async fn domains(
    client: &ApiClient,
    project_reference: &str,
    service_reference: &str,
) -> Result<()> {
    let project = client.find_project(project_reference).await?;
    let found = client.find_service(&project.id, service_reference).await?;
    let domains = client.domains(&found.id).await?;

    let mut table = Table::new(&["host", "tipo", "estado", "id"]);

    for domain in &domains {
        // A disabled hostname is not `failed` and not `pending`: nothing went
        // wrong with it, the service was taken off the internet. Painting its
        // DNS state would say the opposite in red.
        let (state, style) = if domain.enabled {
            (
                domain.state.clone(),
                match domain.state.as_str() {
                    "active" => theme::success(),
                    "failed" => theme::danger(),
                    _ => theme::warning(),
                },
            )
        } else {
            ("desactivado".to_string(), theme::muted())
        };

        table.push(vec![
            Cell::styled(
                domain.host.clone(),
                if domain.enabled {
                    theme::strong()
                } else {
                    theme::muted()
                },
            ),
            Cell::styled(domain.kind.clone(), theme::muted()),
            Cell::styled(state, style),
            Cell::styled(domain.id.clone(), theme::muted()),
        ]);
    }

    if table.is_empty() {
        println!("`{}` no responde en ningún host.", found.name);
        return Ok(());
    }

    table.print();

    if domains.iter().all(|domain| !domain.enabled) {
        println!();
        println!(
            "  {}",
            "El servicio es privado. Sus dominios vuelven con `fundaia expose`."
                .style(theme::muted()),
        );
    }

    for domain in domains
        .iter()
        .filter(|domain| domain.enabled && domain.dns_instructions.is_some())
    {
        println!();
        println!(
            "  {} {}",
            "!".style(theme::warning()),
            domain.dns_instructions.clone().unwrap_or_default(),
        );
    }

    Ok(())
}

/// The persistent directories a service has, and whether the running container
/// actually has them.
///
/// `mounted` is the column worth reading: attaching a volume does not restart
/// anything, so a directory added five minutes ago is not in the container
/// until the next deployment — and a table that only listed names would hide
/// exactly that.
pub async fn volumes(
    client: &ApiClient,
    project_reference: &str,
    service_reference: &str,
) -> Result<()> {
    let project = client.find_project(project_reference).await?;
    let found = client.find_service(&project.id, service_reference).await?;
    let volumes = client.volumes(&found.id).await?;

    let mut table = Table::new(&["ruta", "nombre", "montado", "id"]);

    for volume in &volumes {
        table.push(vec![
            Cell::styled(volume.mount_path.clone(), theme::strong()),
            Cell::plain(volume.name.clone()),
            Cell::styled(
                if volume.mounted {
                    "sí"
                } else {
                    "en el próximo despliegue"
                }
                .to_owned(),
                if volume.mounted {
                    theme::success()
                } else {
                    theme::warning()
                },
            ),
            Cell::styled(volume.id.clone(), theme::muted()),
        ]);
    }

    if table.is_empty() {
        println!("`{}` no tiene ningún volumen.", found.name);
        return Ok(());
    }

    table.print();
    Ok(())
}

/// The Containerfile a service builds with.
///
/// Printed on stdout with nothing around it when `--plain` is given, because
/// the useful thing to do with it is `> Containerfile`, edit, and hand it back
/// to `recipe edit`.
pub async fn recipe(
    client: &ApiClient,
    project_reference: &str,
    service_reference: &str,
    plain: bool,
) -> Result<()> {
    let project = client.find_project(project_reference).await?;
    let found = client.find_service(&project.id, service_reference).await?;
    let recipe = client.recipe(&found.id).await?;

    if plain {
        print!("{}", recipe.containerfile);
        return Ok(());
    }

    println!();
    println!(
        "  {}  {}",
        recipe.builder.style(theme::strong()),
        match recipe.source.as_str() {
            "edited" => "editado a mano — no se vuelve a generar".to_owned(),
            _ => "generado".to_owned(),
        }
        .style(theme::muted()),
    );

    if let Some(port) = recipe.exposed_port {
        println!("  {}", format!("puerto {port}").style(theme::muted()));
    }

    for warning in &recipe.warnings {
        println!("  {} {}", "!".style(theme::warning()), warning);
    }

    println!();
    for line in recipe.containerfile.lines() {
        println!("  {line}");
    }
    println!();

    for note in &recipe.notes {
        println!("  {}", note.style(theme::muted()));
    }

    Ok(())
}

/// A service's copies, newest first.
///
/// The size and the age are the two columns somebody scans for, and `guardada`
/// is the third: a locked copy is the one that will still be there next month,
/// and that is exactly what you want to know before deleting anything.
pub async fn backups(
    client: &ApiClient,
    project_reference: &str,
    service_reference: &str,
) -> Result<()> {
    let project = client.find_project(project_reference).await?;
    let found = client.find_service(&project.id, service_reference).await?;
    let page = client.backups(&found.id).await?;

    if !page.supported {
        println!(
            "`{}` no tiene volumen, así que no hay nada que copiar.",
            found.name
        );
        return Ok(());
    }

    println!();
    println!(
        "  {} {}",
        "programación".style(theme::muted()),
        if page.schedules.is_empty() {
            "ninguna — este servicio no se copia solo".to_owned()
        } else {
            page.schedules.join(", ")
        }
        .style(theme::strong()),
    );
    if let Some(next) = &page.next_at {
        println!(
            "  {} {}",
            "siguiente".style(theme::muted()),
            next.style(theme::muted())
        );
    }
    println!();

    let mut table = Table::new(&["id", "origen", "tamaño", "estado", "hecha"]);

    for backup in &page.backups {
        table.push(vec![
            Cell::styled(backup.id.clone(), theme::muted()),
            Cell::plain(match &backup.schedule {
                Some(schedule) => schedule.clone(),
                None => "a mano".to_owned(),
            }),
            Cell::plain(human_size(backup.size_bytes)),
            Cell::styled(
                if backup.locked {
                    format!("{} · guardada", backup.status)
                } else {
                    backup.status.clone()
                },
                match backup.status.as_str() {
                    "ready" => theme::success(),
                    "failed" => theme::danger(),
                    _ => theme::warning(),
                },
            ),
            Cell::styled(backup.created_at.clone(), theme::muted()),
        ]);
    }

    if table.is_empty() {
        println!("Todavía no hay ninguna copia de `{}`.", found.name);
        return Ok(());
    }

    table.print();
    Ok(())
}

/// Bytes as a person reads them. Two significant figures is all a size column needs.
fn human_size(bytes: u64) -> String {
    const UNITS: [&str; 4] = ["B", "KB", "MB", "GB"];
    let mut size = bytes as f64;
    let mut unit = 0;

    while size >= 1024.0 && unit < UNITS.len() - 1 {
        size /= 1024.0;
        unit += 1;
    }

    if unit == 0 {
        format!("{bytes} B")
    } else {
        format!("{size:.1} {}", UNITS[unit])
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_should_draw_one_block_per_reading() {
        assert_eq!(sparkline(&[1, 2, 3]).chars().count(), 3);
    }

    #[test]
    fn it_should_draw_the_largest_reading_at_full_height() {
        assert!(sparkline(&[1, 10]).ends_with('█'));
    }

    #[test]
    fn it_should_draw_a_flat_series_of_zeroes_at_the_floor() {
        assert_eq!(sparkline(&[0, 0, 0]), "▁▁▁");
    }

    #[test]
    fn it_should_draw_nothing_for_no_readings() {
        assert_eq!(sparkline(&[]), "");
    }

    #[test]
    fn it_should_fill_a_full_meter_completely() {
        assert!(bar(100).contains(&"█".repeat(20)));
    }

    #[test]
    fn it_should_leave_an_empty_meter_unfilled() {
        assert!(bar(0).contains(&"░".repeat(20)));
    }
}