//! `spectra agent`: agents as their owner's delegates (spec §8.1).
//!
//! `add` makes the agent's key pair in its own home, asks the owner to
//! confirm, signs the owner's successor that delegates to it, and records
//! both. There is no agent without an owner.

use super::identity::owner_home;
use super::{call, marks, ui, Ctx};
use anyhow::{bail, Context, Result};
use spectra_core::ids::now_ms;
use spectra_core::keys::{home_identity, KeyPair};
use spectra_core::ledger::Ledger;
use spectra_core::principals::{identity_payload, signed_event, Principal, Principals, DEFAULT_SCOPES};
use std::path::PathBuf;

pub const KINDS: &[&str] = &["claude-code", "antigravity", "kimi-code", "codex", "other"];

pub struct Add {
    pub name: String,
    pub kind: String,
    pub project: String,
    pub home: PathBuf,
    pub uid: Option<u32>,
    pub learn_uid: bool,
    pub expires: Option<String>,
    pub yes: bool,
    pub owner_home: Option<PathBuf>,
}

/// `30m`, `8h`, `7d` from now, in ms; `never` is none.
pub fn expiry(s: &str) -> Result<Option<u64>> {
    let s = s.trim();
    if s == "never" {
        return Ok(None);
    }
    let (n, unit) = s.split_at(s.find(|c: char| !c.is_ascii_digit()).unwrap_or(s.len()));
    let n: u64 = n.parse().with_context(|| format!("{s} is not a length of time (30m, 8h, 7d)"))?;
    let ms = match unit {
        "s" => n * 1000,
        "m" => n * 60_000,
        "h" => n * 3_600_000,
        "d" | "" => n * 86_400_000,
        _ => bail!("{s} is not a length of time (30m, 8h, 7d)"),
    };
    Ok(Some(now_ms() + ms))
}

/// Ask the owner at the terminal; `yes` answers for scripts.
pub fn confirm(question: &str, yes: bool) -> Result<()> {
    use std::io::IsTerminal;
    if yes {
        return Ok(());
    }
    if !std::io::stdin().is_terminal() {
        bail!("{question}: not asked, since this is not a terminal (--yes answers for a script)");
    }
    print!("{} {} {} ", ui::glyph("?", "?"), question, ui::dim("[y/N]"));
    use std::io::Write;
    std::io::stdout().flush().ok();
    let mut line = String::new();
    std::io::stdin().read_line(&mut line)?;
    if !matches!(line.trim().to_ascii_lowercase().as_str(), "y" | "yes") {
        bail!("not delegated: nothing was changed");
    }
    Ok(())
}

pub async fn add(ctx: &Ctx, a: Add) -> Result<i32> {
    if !valid_name(&a.name) {
        bail!("an agent's name is lower-case letters, digits and dashes, starting with a letter or digit, at most 64");
    }
    if !KINDS.contains(&a.kind.as_str()) {
        bail!("--kind is one of {}", KINDS.join(", "));
    }
    let home = owner_home(ctx, a.owner_home.clone());
    let (exists, known) = match ctx.owner_client(&home).await? {
        Some(c) => {
            let agents = call(&c, "GET", "/api/v1/agents", None).await?;
            let projects = call(&c, "GET", "/api/v1/projects", None).await?;
            let has = |v: &serde_json::Value, n: &str| v.as_array().is_some_and(|l| l.iter().any(|x| x["name"] == n));
            (has(&agents, &a.name), has(&projects, &a.project))
        }
        None => {
            let ledger = Ledger::open_read_only(&ctx.db()?).await?;
            let p = Principals::load(&ledger).await?;
            let known: Option<String> =
                sqlx::query_scalar("SELECT name FROM projects WHERE name = ?").bind(&a.project).fetch_optional(ledger.pool()).await?;
            (p.agent_key(&a.name).is_some(), known.is_some())
        }
    };
    if exists {
        bail!("an agent named {} already exists (spectra agent list)", a.name);
    }
    if !known {
        bail!("no project named {} (spectra project add PATH --name {})", a.project, a.project);
    }
    // The agent's key, made once in its own home and reused if `add` is run again.
    let agent = if a.home.join("keys").exists() {
        KeyPair::load_home(&a.home).with_context(|| format!("reading the agent's key in {}", a.home.display()))?
    } else {
        let pair = KeyPair::create_home(&a.home, &a.name, "")?;
        println!("{} {}  {}", ui::done("Created"), ui::subject(format!("{}'s key", a.name)), ui::path(a.home.display()));
        pair
    };
    let expires = a.expires.as_deref().map(expiry).transpose()?.flatten();
    let current = home_identity(&home)?;
    if current.delegate(&agent.key).map(|d| d.expires) != Some(expires) {
        let until = expires.map(|e| format!("until {}", super::format::when(e))).unwrap_or_else(|| "until you disable it".into());
        println!("{}", ui::kv("agent", format!("{}{}{}", ui::subject(&a.name), ui::sep(), ui::hash(agent.key.short(12)))));
        println!("{}", ui::kv("acts for", format!("{}{}{until}", ui::author(&current.name), ui::sep())));
        confirm(&format!("Let {} act for you", a.name), a.yes)?;
        spectra_core::keys::delegate(&home, agent.key, expires)?;
    }
    let w = ctx.owner_writer(&home).await?;
    let mut events: Vec<_> = w.refresh_event(&home).await?.into_iter().collect();
    let owner = KeyPair::load_home(&home)?;
    let mut p = identity_payload(&agent.identity);
    p["name"] = a.name.clone().into();
    p["kind"] = a.kind.clone().into();
    p["project"] = a.project.clone().into();
    p["home"] = a.home.display().to_string().into();
    p["owner"] = owner.key.to_hex().into();
    p["owner_name"] = owner.identity.name.clone().into();
    p["scopes"] = DEFAULT_SCOPES.into();
    if let Some(u) = a.uid {
        p["uid"] = u.into();
    }
    p["learn_uid"] = a.learn_uid.into();
    let d = owner.identity.delegate(&agent.key).context("the delegation vanished")?;
    p["delegation"] = serde_json::json!({ "expires": d.expires });
    events.push(signed_event(&owner, "human", "agent.added", p));
    w.append(events).await?;
    // Label the home, so `spectra mcp --auto` finds this agent from its folder.
    let folder = match (w.client(), w.ledger()) {
        (Some(c), _) => call(c, "GET", "/api/v1/projects", None).await.ok().and_then(|v| {
            v.as_array().and_then(|l| l.iter().find(|p| p["name"] == a.project.as_str()).and_then(|p| p["path"].as_str().map(String::from)))
        }),
        (None, Some(l)) => sqlx::query_scalar::<_, Option<String>>("SELECT path FROM projects WHERE name = ?")
            .bind(&a.project)
            .fetch_optional(l.pool())
            .await
            .ok()
            .flatten()
            .flatten(),
        _ => None,
    };
    super::auto::write_label(&a.home, &a.name, &a.kind, &a.project, folder.as_deref())?;
    println!("{} {}{}{}", ui::done("Added"), ui::subject(&a.name), ui::sep(), ui::author(format!("{}'s agent", owner.identity.name)));
    println!("{}", ui::kv("key", ui::hash(agent.key.to_hex())));
    let until = d.expires.map(|e| format!("until {}", super::format::when(e))).unwrap_or_else(|| "until you disable it".into());
    println!("{}", ui::kv("delegated", until));
    // With Spectra on another machine the shim cannot look the home up.
    let shim = if ctx.remote()?.is_some() {
        format!("spectra mcp --agent {} --home {}", a.name, a.home.display())
    } else {
        format!("spectra mcp --agent {}", a.name)
    };
    println!("  {} {} {}", ui::note(), ui::dim("connect its client with"), ui::id(shim));
    Ok(0)
}

/// An agent as `agent list` reads it, with its presence.
#[derive(sqlx::FromRow)]
struct AgentRow {
    name: String,
    key: String,
    kind: String,
    project: String,
    disabled_ms: Option<i64>,
    presence: Option<String>,
    status: Option<String>,
}

pub async fn list(ctx: &Ctx, json: bool) -> Result<i32> {
    let out = match ctx.owner_client(&owner_home(ctx, None)).await? {
        Some(c) => call(&c, "GET", "/api/v1/agents", None).await?.as_array().cloned().unwrap_or_default(),
        None => list_local(ctx).await?,
    };
    print_list(out, json)
}

async fn list_local(ctx: &Ctx) -> Result<Vec<serde_json::Value>> {
    let ledger = Ledger::open_read_only(&ctx.db()?).await?;
    let p = Principals::load(&ledger).await?;
    let rows: Vec<AgentRow> = sqlx::query_as(
        "SELECT a.name, a.key, a.kind, a.project, a.disabled_ms, p.state AS presence, p.status_text AS status FROM agents a LEFT JOIN presence p ON p.agent = a.name ORDER BY a.name",
    )
    .fetch_all(ledger.pool())
    .await?;
    let owner = p.owner();
    let now = now_ms();
    let mut out = Vec::new();
    for AgentRow { name, key, kind, project, disabled_ms: disabled, presence, status } in rows {
        let k = spectra_core::identity::KeyId::from_hex(&key).context("a stored key")?;
        let state = match p.principal(&k, now) {
            Ok(_) => "ok".to_string(),
            Err(why) => why,
        };
        let expires = owner.and_then(|o| o.delegate(&k)).and_then(|d| d.expires);
        let who = match p.principal(&k, now) {
            Ok(pr @ Principal::Agent { .. }) => pr.display(),
            _ => format!("{name} · {}'s agent", owner.map(|o| o.name.as_str()).unwrap_or("?")),
        };
        let presence = if disabled.is_some() { "offline".to_string() } else { presence.unwrap_or_else(|| "offline".into()) };
        out.push(serde_json::json!({ "name": name, "display": who, "key": key, "kind": kind, "project": project, "state": state, "presence": presence, "status": status, "delegation_expires": expires, "disabled": disabled.is_some() }));
    }
    Ok(out)
}

fn print_list(out: Vec<serde_json::Value>, json: bool) -> Result<i32> {
    if json {
        println!("{}", serde_json::Value::Array(out));
        return Ok(0);
    }
    if out.is_empty() {
        println!("{} {}", ui::note(), ui::dim("no agents yet: spectra agent add NAME --kind KIND --project PROJECT --home DIR"));
    }
    for a in out {
        let state = a["state"].as_str().unwrap_or("");
        let until = a["delegation_expires"].as_u64().map(|e| format!("{}until {}", ui::sep(), super::format::when(e))).unwrap_or_default();
        let display = a["display"].as_str().unwrap_or("");
        let (name, owner) = display.split_once(" · ").unwrap_or((display, ""));
        println!(
            "{} {} {}{}{}",
            marks::health(state),
            marks::presence(a["presence"].as_str().unwrap_or("offline")),
            ui::subject(name),
            ui::sep(),
            ui::author(owner)
        );
        if let Some(st) = a["status"].as_str() {
            println!("  {} {}", ui::note(), st);
        }
        println!(
            "  {}",
            ui::dim(format!(
                "{}{}{}{}{}{until}",
                a["kind"].as_str().unwrap_or(""),
                ui::sep(),
                a["project"].as_str().unwrap_or(""),
                ui::sep(),
                &a["key"].as_str().unwrap_or("")[..12]
            ))
        );
        if state != "ok" {
            println!("  {} {}", ui::caution(), ui::warn(state));
        }
    }
    Ok(0)
}

pub async fn disable(ctx: &Ctx, name: &str, owner_home_flag: Option<PathBuf>) -> Result<i32> {
    let home = owner_home(ctx, owner_home_flag);
    let w = ctx.owner_writer(&home).await?;
    let known = match (w.ledger(), w.client()) {
        (_, Some(c)) => call(c, "GET", "/api/v1/agents", None).await?.as_array().is_some_and(|l| l.iter().any(|x| x["name"] == name)),
        (Some(l), None) => Principals::load(l).await?.agent_key(name).is_some(),
        (None, None) => false,
    };
    if !known {
        bail!("no agent named {name}");
    }
    // Stop delegating to its key too, where the owner's identity names it.
    if let Some(key) = agent_key(&w, name).await? {
        if home_identity(&home)?.delegate(&key).is_some() {
            spectra_core::keys::undelegate(&home, key)?;
        }
    }
    let mut events: Vec<_> = w.refresh_event(&home).await?.into_iter().collect();
    let owner = KeyPair::load_home(&home)?;
    events.push(signed_event(&owner, "human", "agent.disabled", serde_json::json!({ "name": name })));
    w.append(events).await?;
    println!("{} {}", ui::done("Disabled"), ui::subject(name));
    println!("  {} {}", ui::note(), ui::dim("its key is refused from now on; earlier events keep their signatures"));
    Ok(0)
}

/// An agent's key by name, from the daemon or the ledger here.
async fn agent_key(w: &super::Writer, name: &str) -> Result<Option<spectra_core::identity::KeyId>> {
    Ok(match (w.client(), w.ledger()) {
        (Some(c), _) => call(c, "GET", "/api/v1/agents", None).await?.as_array().and_then(|l| {
            l.iter().find(|x| x["name"] == name).and_then(|x| x["key"].as_str().and_then(spectra_core::identity::KeyId::from_hex))
        }),
        (None, Some(l)) => Principals::load(l).await?.agent_key(name),
        (None, None) => None,
    })
}

/// `spectra agent allow NAME --channel CHANNEL [--remove]`: the owner lets
/// an agent post in another project's channel (spec §8.4).
pub async fn allow(ctx: &Ctx, name: &str, channel: &str, remove: bool, owner_home_flag: Option<PathBuf>) -> Result<i32> {
    let channel = channel.trim_start_matches('#');
    let scope = format!("channel:{channel}");
    if !spectra_core::principals::grantable(&scope) {
        bail!("{channel} is not a channel name");
    }
    let home = owner_home(ctx, owner_home_flag);
    let w = ctx.owner_writer(&home).await?;
    agent_key(&w, name).await?.with_context(|| format!("no agent named {name}"))?;
    let mut events: Vec<_> = w.refresh_event(&home).await?.into_iter().collect();
    let owner = KeyPair::load_home(&home)?;
    events.push(signed_event(&owner, "human", "agent.scoped", serde_json::json!({ "name": name, "scope": scope, "grant": !remove })));
    w.append(events).await?;
    if remove {
        println!("{} {} {}", ui::done("Removed"), ui::subject(name), ui::dim(format!("may no longer post in #{channel}")));
    } else {
        println!("{} {} {}", ui::done("Allowed"), ui::subject(name), ui::dim(format!("may post in #{channel}")));
    }
    Ok(0)
}

/// `spectra agent renew NAME --expires 8h`: the owner's successor with a
/// new expiry for the agent's key, recorded.
pub async fn renew(ctx: &Ctx, name: &str, expires: &str, owner_home_flag: Option<PathBuf>) -> Result<i32> {
    let home = owner_home(ctx, owner_home_flag);
    let w = ctx.owner_writer(&home).await?;
    let key = agent_key(&w, name).await?.with_context(|| format!("no agent named {name}"))?;
    let expires = expiry(expires)?;
    spectra_core::keys::delegate(&home, key, expires)?;
    let events: Vec<_> = w.refresh_event(&home).await?.into_iter().collect();
    w.append(events).await?;
    let until = expires.map(|e| format!("until {}", super::format::when(e))).unwrap_or_else(|| "until you disable it".into());
    println!("{} {}{}{}", ui::done("Renewed"), ui::subject(name), ui::sep(), until);
    Ok(0)
}

pub fn valid_name(n: &str) -> bool {
    !n.is_empty()
        && n.len() <= 64
        && n.bytes().next().is_some_and(|b| b.is_ascii_lowercase() || b.is_ascii_digit())
        && n.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'-')
}