//! 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 })

}