//! `spectra connect` (spec §8.6, spectra#21): a workstation trusts a server

//! because the owner delegates to its instance key and that key vouches for

//! its certificate; it claims a server set up with `init --owner`, even

//! though delegating changed the owner's KeyId; a new certificate is

//! refused until connect runs again; someone else's server is refused.

mod common;

use common::{delegate, hermetic, run, text, Serving};

use spectra_core::keys::KeyPair;

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

use spectra_mcp::tls::Pinned;

use std::path::Path;

/// A server in `s` set up for the owner whose home is `owner_home`.

fn server_for(s: &Path, owner_home: &Path) -> (Serving, u16) {

    let owner = KeyPair::load_home(owner_home).unwrap();

    let o = run(s, &["init", "--owner", &owner.key.to_hex(), "--name", "earth"]);

    assert!(o.status.success(), "{}", text(&o));

    Serving::start_tls(s)

}

async fn instance_owner(port: u16) -> serde_json::Value {

    let p = Pinned::new(None);

    let c = Client::at(Endpoint::Tls { addr: format!("127.0.0.1:{port}"), config: p.client_config().unwrap() }, None);

    c.send("GET", "/api/v1/instance", &[], vec![]).await.unwrap().json().unwrap()["owner"].clone()

}

#[tokio::test]

async fn the_owner_connects_delegates_and_claims() {

    let (sd, cd) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());

    let (s, c) = (sd.path(), cd.path());

    KeyPair::create_home(&c.join("owner"), "Andy McCall", "").unwrap();

    let (srv, port) = server_for(s, &c.join("owner"));

    let url = format!("https://127.0.0.1:{port}");

    // First contact: not yet delegated, so not trusted; told what to run.

    let o = run(c, &["connect", &url]);

    assert_eq!(o.status.code(), Some(1), "{}", text(&o));

    assert!(text(&o).contains("oxy identity delegate add"), "{}", text(&o));

    let saved = c.join(".config/spectra/earth-instance.identity");

    assert!(saved.exists(), "the instance's public identity is saved to delegate to");

    assert!(!c.join(".config/spectra/client.toml").exists(), "nothing trusted yet");

    // The owner delegates (which gives their identity a new KeyId) ...

    let instance = KeyPair::instance(&s.join("data"), "earth").unwrap();

    assert_eq!(oxy_core::identity::Identity::decode(&std::fs::read(&saved).unwrap()).unwrap().hash(), instance.key);

    delegate(&c.join("owner"), &instance);

    let current = KeyPair::load_home(&c.join("owner")).unwrap();

    // ... and connects again: trusted, pinned, and claimed as theirs.

    let o = run(c, &["connect", &url]);

    assert!(o.status.success(), "{}", text(&o));

    assert!(text(&o).contains("Claimed"), "{}", text(&o));

    let cfg = std::fs::read_to_string(c.join(".config/spectra/client.toml")).unwrap();

    assert!(cfg.contains(&instance.key.to_hex()) && cfg.contains("tls_spki"), "{cfg}");

    assert_eq!(instance_owner(port).await, current.key.to_hex(), "recorded at the owner's current identity");

    // Again: nothing to claim, still trusted.

    let o = run(c, &["connect", &url]);

    assert!(o.status.success(), "{}", text(&o));

    assert!(text(&o).contains("Connected"), "{}", text(&o));

    srv.stop();

    // A new certificate (the old one lost) is refused on the old pin ...

    std::fs::remove_file(s.join("data/keys/tls.crt")).unwrap();

    std::fs::remove_file(s.join("data/keys/tls.key")).unwrap();

    let (srv, port) = Serving::start_tls(s);

    let url = format!("https://127.0.0.1:{port}");

    let cfg = std::fs::read_to_string(c.join(".config/spectra/client.toml")).unwrap();

    let old_pin: [u8; 32] =

        hex::decode(cfg.lines().find(|l| l.starts_with("tls_spki")).unwrap().split('"').nth(1).unwrap()).unwrap().try_into().unwrap();

    let pinned = Client::at(Endpoint::tls(&url, old_pin).unwrap(), None);

    assert!(pinned.send("GET", "/api/v1/instance", &[], vec![]).await.is_err());

    // ... until connect checks that the same instance key vouches for it.

    let o = run(c, &["connect", &url]);

    assert!(o.status.success(), "{}", text(&o));

    let cfg2 = std::fs::read_to_string(c.join(".config/spectra/client.toml")).unwrap();

    assert_ne!(cfg, cfg2, "re-pinned");

    srv.stop();

    let o = hermetic(s).args(["admin", "verify"]).output().unwrap();

    assert!(o.status.success(), "{}", text(&o));

}

#[test]

fn someone_elses_server_is_refused() {

    let (sd, cd, md) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());

    let (s, c, m) = (sd.path(), cd.path(), md.path());

    KeyPair::create_home(&c.join("owner"), "Andy McCall", "").unwrap();

    KeyPair::create_home(&m.join("owner"), "Mallory", "").unwrap();

    let (srv, port) = server_for(s, &m.join("owner"));

    let o = run(c, &["connect", &format!("https://127.0.0.1:{port}")]);

    assert!(!o.status.success());

    assert!(text(&o).contains("was set up for"), "{}", text(&o));

    srv.stop();

}