//! Thin clients of a hub's proposals (hub spec §7): `oxy proposal show`,
//! `oxy proposal land`, and `oxy seal --proposal`. The hub's JSON is read
//! by field name (hub-api `Proposal`); nothing here needs the hub crate.

use super::{open, ui};
use anyhow::{anyhow, Context, Result};
use oxy_core::hash::ChangeHash;
use oxy_core::repo::Repo;
use serde_json::Value;

/// `https://hub/{owner}/{name}/proposal/{n}` (or the API URL) to the API
/// URL and the repository's clone URL.
pub fn api_url(url: &str) -> Result<(String, String)> {
    let url = url.trim_end_matches('/');
    if url.contains("/api/v1/repos/") {
        let (base, rest) = url.split_once("/api/v1/repos/").unwrap();
        let mut parts = rest.split('/');
        let (owner, name) = (parts.next().unwrap_or(""), parts.next().unwrap_or(""));
        return Ok((url.to_string(), format!("{base}/{owner}/{name}")));
    }
    let (repo_url, number) = url
        .rsplit_once("/proposal/")
        .ok_or_else(|| anyhow!("{url} is not a proposal URL (…/OWNER/NAME/proposal/N)"))?;
    let (base, slug) = repo_url
        .rsplit_once('/')
        .and_then(|(b, n)| b.rsplit_once('/').map(|(bb, o)| (bb, format!("{o}/{n}"))))
        .ok_or_else(|| anyhow!("{url} is not a proposal URL"))?;
    Ok((
        format!("{base}/api/v1/repos/{slug}/proposals/{number}"),
        repo_url.to_string(),
    ))
}

pub fn fetch(repo: &Repo, url: &str) -> Result<(Value, String)> {
    let (api, repo_url) = api_url(url)?;
    let options = repo.options_for_url(&repo_url);
    let body = oxy_core::protocol::http_get(&api, &options).map_err(|e| anyhow!("{e}"))?;
    let v: Value = serde_json::from_slice(&body).context("the hub did not answer with JSON")?;
    Ok((v, repo_url))
}

fn hashes(v: &Value, key: &str) -> Vec<ChangeHash> {
    v.get(key)
        .and_then(Value::as_array)
        .map(|a| {
            a.iter()
                .filter_map(|x| x.as_str().and_then(ChangeHash::from_hex))
                .collect()
        })
        .unwrap_or_default()
}

fn change_hashes(v: &Value) -> Vec<ChangeHash> {
    v.get("changes")
        .and_then(Value::as_array)
        .map(|a| {
            a.iter()
                .filter_map(|c| {
                    c.get("hash")
                        .and_then(Value::as_str)
                        .and_then(ChangeHash::from_hex)
                })
                .collect()
        })
        .unwrap_or_default()
}

fn text<'a>(v: &'a Value, key: &str) -> &'a str {
    v.get(key).and_then(Value::as_str).unwrap_or("")
}

pub fn show(url: &str, as_json: bool) -> Result<i32> {
    let repo = open()?;
    let (v, _) = fetch(&repo, url)?;
    if as_json {
        println!("{v}");
        return Ok(0);
    }
    println!(
        "{} #{} {}",
        ui::done("Proposal"),
        v.get("number").and_then(Value::as_i64).unwrap_or(0),
        ui::bookmark(text(&v, "title"))
    );
    println!("{}", ui::kv("state", text(&v, "state")));
    println!("{}", ui::kv("target", ui::bookmark(text(&v, "target"))));
    println!("{}", ui::kv("author", ui::author(text(&v, "author"))));
    let changes = v
        .get("changes")
        .and_then(Value::as_array)
        .cloned()
        .unwrap_or_default();
    println!("{}", ui::kv("changes", changes.len().to_string()));
    for c in &changes {
        println!(
            "  {} {}",
            ui::hash(&text(c, "hash")[..12.min(text(c, "hash").len())]),
            text(c, "message").lines().next().unwrap_or("")
        );
    }
    if v.get("conflicted")
        .and_then(Value::as_bool)
        .unwrap_or(false)
    {
        println!("{}", ui::warn("landing would carry conflicts"));
    }
    if let Some(blockers) = v.get("blockers").and_then(Value::as_array) {
        for b in blockers {
            println!("  {} {}", ui::warn("blocked:"), b.as_str().unwrap_or(""));
        }
    }
    let approvals = v
        .get("approvals")
        .and_then(Value::as_array)
        .cloned()
        .unwrap_or_default();
    for a in &approvals {
        let mark = if a.get("sealed").and_then(Value::as_bool).unwrap_or(false) {
            ui::done("approved")
        } else {
            ui::warn("pending seal")
        };
        println!("  {mark} {}", text(a, "account"));
    }
    Ok(0)
}

/// Seal every change of the proposal with your key and push the seal to
/// the hub, so your approval counts (hub spec §7.4).
pub fn seal(url: &str, as_json: bool) -> Result<i32> {
    let repo = open()?;
    let (v, repo_url) = fetch(&repo, url)?;
    let hashes = change_hashes(&v);
    if hashes.is_empty() {
        anyhow::bail!("the proposal has no changes to seal");
    }
    ensure_changes(&repo, &repo_url, &hashes, &hashes)?;
    let mut refs = Vec::new();
    for chunk in hashes.chunks(oxy_core::attest::MAX_SEAL_HASHES) {
        refs.push(repo.seal(chunk)?);
    }
    let remote = repo.remote_for_url(&repo_url).ok_or_else(|| {
        anyhow!("no remote is configured for {repo_url}; add one with `oxy remote add`")
    })?;
    repo.push_seals(&remote, &refs)?;
    if as_json {
        let list: Vec<String> = hashes
            .iter()
            .map(|h| format!("\"{}\"", h.to_hex()))
            .collect();
        println!("{{\"sealed\":[{}],\"pushed\":true}}", list.join(","));
    } else {
        println!(
            "{} {} change{} of the proposal and pushed the seal to {remote}",
            ui::done("Sealed"),
            hashes.len(),
            if hashes.len() == 1 { "" } else { "s" }
        );
    }
    Ok(0)
}

/// Fetch the proposal's changes (and anything they need) from the hub
/// into the local store.
fn ensure_changes(
    repo: &Repo,
    repo_url: &str,
    want: &[ChangeHash],
    _changes: &[ChangeHash],
) -> Result<()> {
    let missing: Vec<ChangeHash> = want
        .iter()
        .copied()
        .filter(|h| !repo.store().has(h))
        .collect();
    if missing.is_empty() {
        return Ok(());
    }
    let (_, remote) = repo.open_remote_at(repo_url)?;
    let view = repo.view()?;
    let have = repo.known_heads(&view)?;
    let needed = remote.negotiate(&have, want)?;
    let bundle = remote.fetch(&needed, repo.config.max_blob)?;
    repo.import_bundle(&bundle, false)?;
    Ok(())
}

/// Land the proposal from this client: fetch its changes, set the target
/// bookmark to the projected heads, and push with your own key (hub spec
/// §7.6).
pub fn land(url: &str, force: bool) -> Result<i32> {
    let repo = open()?;
    let (v, repo_url) = fetch(&repo, url)?;
    let state = text(&v, "state");
    if state != "open" && !force {
        anyhow::bail!("the proposal is {state}, not open (use --force to land anyway)");
    }
    if !v.get("landable").and_then(Value::as_bool).unwrap_or(false) && !force {
        let blockers: Vec<String> = v
            .get("blockers")
            .and_then(Value::as_array)
            .map(|a| {
                a.iter()
                    .filter_map(|b| b.as_str().map(String::from))
                    .collect()
            })
            .unwrap_or_default();
        anyhow::bail!(
            "the hub says the proposal cannot land yet: {} (use --force to land anyway)",
            blockers.join("; ")
        );
    }
    let target = text(&v, "target").to_string();
    let heads = hashes(&v, "projected_heads");
    if heads.is_empty() {
        anyhow::bail!("the hub has not computed the projected state yet; try again shortly");
    }
    ensure_changes(&repo, &repo_url, &heads, &change_hashes(&v))?;
    let remote = repo.remote_for_url(&repo_url).ok_or_else(|| {
        anyhow!("no remote is configured for {repo_url}; add one with `oxy remote add`")
    })?;
    // Bring the target bookmark up to date first, so the push is a fast-forward.
    repo.fetch(&remote)?;
    repo.bookmark_set(&target, &heads)?;
    let results = repo.push_bookmark(&remote, &target, false)?;
    for r in &results {
        if r.ok {
            println!(
                "{} {}/{} - landed proposal",
                ui::done("Pushed"),
                remote,
                r.name
            );
        } else {
            println!(
                "{} {}/{} - {}",
                ui::warn("Rejected"),
                remote,
                r.name,
                r.reason
            );
        }
    }
    Ok(if results.iter().all(|r| r.ok) { 0 } else { 1 })
}