fundaia 0.15.0

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

use crate::api::client::ApiClient;
use crate::output::{self, Format};
use crate::render::table::{Cell, Table};
use crate::render::theme;
use crate::render::time;

/// Spanish for the two roles, so the output reads like the web interface does.
fn role_label(role: &str) -> &str {
    match role {
        "admin" => "administrador",
        _ => "miembro",
    }
}

fn status_label(status: &str) -> &str {
    match status {
        "pending" => "pendiente",
        "accepted" => "aceptada",
        _ => "caducada",
    }
}

pub async fn list(client: &ApiClient, format: Format) -> Result<()> {
    let workspaces = client.workspaces().await?;

    if format.is_json() {
        output::emit(&workspaces);
        return Ok(());
    }

    let mut table = Table::new(&["id", "espacio", "slug", "tu papel"]);

    for workspace in &workspaces {
        table.push(vec![
            Cell::styled(workspace.id.clone(), theme::muted()),
            Cell::styled(workspace.name.clone(), theme::strong()),
            Cell::plain(workspace.slug.clone()),
            Cell::plain(
                workspace
                    .role
                    .as_deref()
                    .map(role_label)
                    // The instance owner reaches every workspace and is in none.
                    .unwrap_or("—")
                    .to_string(),
            ),
        ]);
    }

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

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

/// Euros, from whole millionths, and never rounded up to nothing.
///
/// Four decimals under a cent for the same reason the web uses them: one prompt
/// costs thousandths, and `0,00 €` reads as free rather than as not much.
fn format_euros(micros: i64) -> String {
    let euros = micros as f64 / 1e6;
    if micros == 0 {
        return "0 €".to_string();
    }
    if euros.abs() < 0.01 {
        return format!("{euros:.4} €");
    }

    format!("{euros:.2} €")
}

/// What is left of the prepaid credit, and what has been moving it.
///
/// The agent is the one thing here paid for in advance, so this is the command
/// to reach for when a `claude-code` service refuses to deploy: the refusal says
/// there is no credit, and this says how much there is and where it went.
pub async fn credits(client: &ApiClient, reference: Option<&str>, format: Format) -> Result<()> {
    let workspace = client.find_workspace(reference).await?;
    let credits = client.credits(&workspace.id).await?;

    if format.is_json() {
        output::emit(&credits);
        return Ok(());
    }

    println!();
    println!("  {}", workspace.name.style(theme::strong()));
    println!();
    println!(
        "  {} {}",
        "saldo   ".style(theme::muted()),
        format_euros(credits.balance_micros).style(theme::strong()),
    );
    println!(
        "  {} {}",
        "recargado".style(theme::muted()),
        format_euros(credits.added_micros),
    );
    println!(
        "  {} {}",
        "gastado ".style(theme::muted()),
        format_euros(credits.spent_micros),
    );

    if !credits.may_run_agent {
        println!();
        println!(
            "  {}",
            "Sin saldo: los agentes de este espacio están parados.".style(theme::warning()),
        );
    } else if credits.running_low {
        println!();
        println!(
            "  {}",
            format!(
                "Queda el {} % del crédito.",
                credits.remaining_percent.unwrap_or(0)
            )
            .style(theme::warning()),
        );
    }

    if credits.history.is_empty() {
        println!();
        return Ok(());
    }

    println!();
    let mut table = Table::new(&["cuándo", "concepto", "importe"]);
    for entry in &credits.history {
        // The sign is the whole of what a row means, so it is spelled out rather
        // than left to a minus somebody has to notice.
        let amount = format!(
            "{}{}",
            if entry.amount_micros >= 0 { "+" } else { "−" },
            format_euros(entry.amount_micros.abs())
        );

        table.push(vec![
            Cell::styled(
                time::relative_time(&entry.created_at).unwrap_or_else(|| entry.created_at.clone()),
                theme::muted(),
            ),
            Cell::plain(entry.detail.clone()),
            Cell::styled(amount, theme::strong()),
        ]);
    }
    table.print();

    Ok(())
}

/// Who shares a workspace, and who has been asked to.
///
/// Both lists in one command because they answer the same question — *who can
/// see my projects* — and a pending invitation is an answer to it too.
pub async fn members(client: &ApiClient, reference: Option<&str>, format: Format) -> Result<()> {
    let workspace = client.find_workspace(reference).await?;

    if format.is_json() {
        let (members, invitations) = tokio::join!(
            client.members(&workspace.id),
            client.invitations(&workspace.id)
        );
        output::emit(&serde_json::json!({
            "workspace": workspace,
            "members": members?,
            "invitations": invitations?,
        }));
        return Ok(());
    }

    println!();
    println!("  {}", workspace.name.style(theme::strong()));
    println!();

    let members = client.members(&workspace.id).await?;
    let mut table = Table::new(&["usuario", "github", "correo", "papel", "visto"]);

    for member in &members {
        table.push(vec![
            Cell::styled(
                member
                    .display_name
                    .clone()
                    .unwrap_or_else(|| member.user_id.clone()),
                theme::strong(),
            ),
            Cell::plain(
                member
                    .github_login
                    .as_ref()
                    .map(|login| format!("@{login}"))
                    .unwrap_or_else(|| "—".to_string()),
            ),
            Cell::plain(member.email.clone().unwrap_or_else(|| "—".to_string())),
            Cell::plain(role_label(&member.role).to_string()),
            // "Never" and "we have no idea" are the same column here on
            // purpose: both mean there is nothing to go on, and a server too
            // old to answer is not worth a word of its own in a member list.
            Cell::styled(
                member
                    .last_seen_at
                    .as_deref()
                    .and_then(time::relative_time)
                    .unwrap_or_else(|| "—".to_string()),
                theme::muted(),
            ),
        ]);
    }

    table.print();

    let pending: Vec<_> = client
        .invitations(&workspace.id)
        .await?
        .into_iter()
        .filter(|invitation| invitation.status == "pending")
        .collect();

    if pending.is_empty() {
        return Ok(());
    }

    println!();
    println!("  {}", "Invitaciones pendientes".style(theme::muted()));
    println!();

    let mut invitations = Table::new(&["id", "correo", "papel", "estado"]);
    for invitation in &pending {
        invitations.push(vec![
            Cell::styled(invitation.id.clone(), theme::muted()),
            Cell::styled(invitation.email.clone(), theme::strong()),
            Cell::plain(role_label(&invitation.role).to_string()),
            Cell::plain(status_label(&invitation.status).to_string()),
        ]);
    }
    invitations.print();

    Ok(())
}

/// Sends an invitation and prints the link it sent.
///
/// The link is printed on purpose: whoever runs this is often on a machine with
/// no mail client, and delivery is the part most likely to be slow — or off
/// entirely on an instance with no provider configured. Copying it into a chat
/// window is then the fastest path, and it is the same credential either way.
pub async fn invite(
    client: &ApiClient,
    reference: Option<&str>,
    email: &str,
    admin: bool,
) -> Result<()> {
    let workspace = client.find_workspace(reference).await?;
    let role = if admin { "admin" } else { "member" };

    let sent = client.invite(&workspace.id, email, role).await?;

    println!();
    println!(
        "  {} Invitación enviada a {} como {}",
        theme::CHECK.style(theme::success()),
        email.style(theme::strong()),
        role_label(role),
    );
    println!("    {}", sent.accept_url.style(theme::muted()));
    println!();

    Ok(())
}

pub async fn revoke(
    client: &ApiClient,
    reference: Option<&str>,
    invitation_id: &str,
) -> Result<()> {
    let workspace = client.find_workspace(reference).await?;
    client
        .revoke_invitation(&workspace.id, invitation_id)
        .await?;

    println!(
        "  {} Invitación retirada",
        theme::CHECK.style(theme::success())
    );
    Ok(())
}

pub async fn remove(client: &ApiClient, reference: Option<&str>, user_id: &str) -> Result<()> {
    let workspace = client.find_workspace(reference).await?;
    client.remove_member(&workspace.id, user_id).await?;

    println!(
        "  {} {user_id} ya no está en {}",
        theme::CHECK.style(theme::success()),
        workspace.name.style(theme::strong()),
    );
    Ok(())
}