//! Commands a program uses to set Spectra up and to talk to it (spec

//! §18.1): `spectra status` says what is set up, `spectra probe` what a

//! server is before trusting it, and `spectra bridge` signs for a program

//! that cannot (the VS Code extension).

use super::identity::owner_home;

use super::{ui, Ctx};

use anyhow::{bail, Context, Result};

use serde_json::{json, Value};

use spectra_mcp::client::{host_port, Client, Endpoint};

use spectra_mcp::tls::Pinned;

use std::path::PathBuf;

/// `spectra status [--json]`: the identity, the server or local Spectra.

pub async fn status(ctx: &Ctx, as_json: bool) -> Result<i32> {

    let home = owner_home(ctx, None);

    let identity = spectra_core::keys::KeyPair::load_home(&home).ok();

    let remote = ctx.remote()?;

    let initialised = ctx.data.join("spectra.db").exists();

    let serving = initialised && Client::alive(&ctx.socket()).await;

    let reachable = match &remote {

        Some(c) => Client::at(c.endpoint()?, None).send("GET", "/api/v1/health", &[], vec![]).await.is_ok_and(|r| r.status < 500),

        None => serving,

    };

    let v = json!({

        "version": env!("SPECTRA_VERSION_LONG"),

        "home": home.display().to_string(),

        "identity": identity.as_ref().map(|p| json!({ "name": p.identity.name, "key": p.key.to_hex() })),

        "server": remote.as_ref().map(|c| json!({ "url": c.server, "instance": c.instance })),

        "local": { "data": ctx.data.display().to_string(), "initialised": initialised, "serving": serving },

        "reachable": reachable,

    });

    if as_json {

        println!("{v}");

        return Ok(0);

    }

    println!("{}", ui::kv("version", env!("SPECTRA_VERSION_LONG")));

    match &identity {

        Some(p) => println!("{}", ui::kv("you", format!("{}{}{}", ui::author(&p.identity.name), ui::sep(), ui::hash(p.key.short(12))))),

        None => println!("{}", ui::kv("you", ui::warn("no identity yet: spectra identity create --name NAME"))),

    }

    match &remote {

        Some(c) => println!("{}", ui::kv("spectra", format!("{}{}", ui::path(&c.server), if reachable { "" } else { " (not answering)" }))),

        None if initialised => println!(

            "{}",

            ui::kv("spectra", format!("{}{}", ui::path(ctx.data.display()), if serving { " (serving)" } else { " (not serving)" }))

        ),

        None => println!("{}", ui::kv("spectra", ui::warn("none yet: spectra init here, or spectra connect https://HOST:7350"))),

    }

    Ok(0)

}

/// `spectra probe URL [--json]`: who a server says it is, checked against

/// its certificate, without trusting it.

pub async fn probe(url: &str, as_json: bool) -> Result<i32> {

    let addr = host_port(url)?;

    let seen = Pinned::new(None);

    let c = Client::at(Endpoint::Tls { addr: addr.clone(), config: seen.client_config()? }, None);

    let r = c.send("GET", "/api/v1/instance", &[], vec![]).await.with_context(|| format!("reaching https://{addr}"))?;

    if r.status != 200 {

        bail!("https://{addr} answered {} to /api/v1/instance: is it a Spectra?", r.status);

    }

    let answer = r.json()?;

    let (_, pin) = seen.seen().context("the server showed no certificate")?;

    let checked = spectra_mcp::instance::check(&answer, &pin)?;

    let mine = spectra_core::keys::KeyPair::load_home(&spectra_core::keys::default_home()).ok();

    let waiting = answer.get("named_owner").and_then(Value::as_str).map(String::from);

    let v = json!({

        "url": format!("https://{addr}"),

        "name": checked.name,

        "instance": checked.instance.hash().to_hex(),

        "owner": checked.owner,

        "waiting_for": waiting,

        "yours": mine.as_ref().is_some_and(|m| {

            let me = m.key.to_hex();

            checked.owner.as_deref() == Some(me.as_str()) || waiting.as_deref() == Some(me.as_str())

                || [checked.owner.as_deref(), waiting.as_deref()].into_iter().flatten()

                    .any(|k| spectra_core::identity::KeyId::from_hex(k).is_some_and(|k| spectra_core::keys::identity_in(&spectra_core::keys::default_home(), &k).is_some()))

        }),

        "tls_spki": hex::encode(pin),

    });

    if as_json {

        println!("{v}");

    } else {

        println!("{}", ui::kv("server", ui::path(v["url"].as_str().unwrap_or(""))));

        println!("{}", ui::kv("name", v["name"].as_str().unwrap_or("")));

        println!("{}", ui::kv("instance", ui::hash(v["instance"].as_str().unwrap_or(""))));

        let whose = match (v["owner"].as_str(), v["waiting_for"].as_str()) {

            (Some(o), _) => format!("owned by {}", &o[..12.min(o.len())]),

            (None, Some(w)) => format!("waiting to be claimed by {}", &w[..12.min(w.len())]),

            _ => "no owner".into(),

        };

        println!("{}", ui::kv("owner", whose));

    }

    Ok(0)

}

/// `spectra bridge [--port 0]`: sign as the owner for the program that

/// started it; prints `{ "url", "token" }` and ends with standard input.

pub async fn bridge(ctx: &Ctx, port: u16, owner_home_flag: Option<PathBuf>) -> Result<i32> {

    let home = owner_home(ctx, owner_home_flag);

    let client =

        ctx.owner_client(&home).await?.context("no Spectra to bridge to: spectra init here, or spectra connect https://HOST:7350")?;

    let listener = tokio::net::TcpListener::bind(("127.0.0.1", port)).await.with_context(|| format!("binding 127.0.0.1:{port}"))?;

    let port = listener.local_addr()?.port();

    let token = spectra_mcp::bridge::token();

    println!("{}", json!({ "url": format!("http://127.0.0.1:{port}"), "token": token }));

    use std::io::Write;

    std::io::stdout().flush().ok();

    let app = spectra_mcp::bridge::router(client, token, port);

    axum::serve(listener, app)

        .with_graceful_shutdown(async {

            // Ends when the program that started it closes our input, or on Ctrl-C.

            let stdin = async {

                let mut buf = [0u8; 256];

                let mut input = tokio::io::stdin();

                loop {

                    match tokio::io::AsyncReadExt::read(&mut input, &mut buf).await {

                        Ok(0) | Err(_) => return,

                        Ok(_) => {}

                    }

                }

            };

            tokio::select! {

                _ = stdin => {}

                _ = tokio::signal::ctrl_c() => {}

            }

        })

        .await?;

    Ok(0)

}