//! What the VS Code extension drives (spec §18.1): `spectra status` and
//! `spectra probe` say what is set up and what a server is, and `spectra
//! bridge` signs for the extension, refusing anyone without its token and
//! any web page.

mod common;

use common::{add_agent, hermetic, run, setup, text, Serving};
use serde_json::Value;
use std::io::{BufRead, BufReader, Read, Write};
use std::process::Stdio;

fn http(url: &str, method: &str, path: &str, headers: &[(&str, &str)], body: &str) -> (u16, String) {
    let hp = url.strip_prefix("http://").unwrap();
    let mut s = std::net::TcpStream::connect(hp).unwrap();
    s.set_read_timeout(Some(std::time::Duration::from_secs(10))).unwrap();
    let mut req = format!("{method} {path} HTTP/1.1\r\nconnection: close\r\ncontent-length: {}\r\n", body.len());
    if !headers.iter().any(|(k, _)| k.eq_ignore_ascii_case("host")) {
        req.push_str(&format!("host: {hp}\r\n"));
    }
    for (k, v) in headers {
        req.push_str(&format!("{k}: {v}\r\n"));
    }
    req.push_str("\r\n");
    req.push_str(body);
    s.write_all(req.as_bytes()).unwrap();
    let mut out = String::new();
    let _ = s.read_to_string(&mut out);
    let status = out.split_whitespace().nth(1).and_then(|c| c.parse().ok()).unwrap_or(0);
    (status, out.split_once("\r\n\r\n").map(|x| x.1.to_string()).unwrap_or_default())
}

#[test]
fn status_says_what_is_set_up() {
    let dir = tempfile::tempdir().unwrap();
    let d = dir.path();
    let v: Value = serde_json::from_slice(&run(d, &["status", "--json"]).stdout).unwrap();
    assert!(v["identity"].is_null() && v["server"].is_null() && v["local"]["initialised"] == false, "{v}");
    let made: Value = serde_json::from_slice(&run(d, &["identity", "create", "--name", "Andy McCall", "--json"]).stdout).unwrap();
    assert_eq!(made["key"].as_str().unwrap().len(), 64);
    assert!(run(d, &["init"]).status.success());
    let v: Value = serde_json::from_slice(&run(d, &["status", "--json"]).stdout).unwrap();
    assert_eq!(v["identity"]["name"], "Andy McCall", "init made a successor (it delegates to the instance), so the key moved on");
    assert_ne!(v["identity"]["key"], made["key"]);
    assert_eq!(v["local"]["initialised"], true);
    assert_eq!(v["reachable"], false, "not serving");
}

#[tokio::test]
async fn the_bridge_signs_for_its_holder_only() {
    let dir = setup();
    let d = dir.path();
    add_agent(d, "claude-oxygen", &[]);
    let srv = Serving::start(d);
    let mut child = hermetic(d).args(["bridge"]).stdin(Stdio::piped()).stdout(Stdio::piped()).spawn().unwrap();
    let mut line = String::new();
    BufReader::new(child.stdout.take().unwrap()).read_line(&mut line).unwrap();
    let hello: Value = serde_json::from_str(&line).unwrap();
    let (url, token) = (hello["url"].as_str().unwrap().to_string(), hello["token"].as_str().unwrap().to_string());
    let bearer = format!("Bearer {token}");

    // Signed as the owner, so the API answers as for the human.
    let (status, body) = http(&url, "GET", "/api/v1/brief", &[("authorization", &bearer)], "");
    assert_eq!(status, 200, "{body}");
    assert_eq!(serde_json::from_str::<Value>(&body).unwrap()["actor"], "human");
    let (status, body) = http(
        &url,
        "PUT",
        "/api/v1/briefs",
        &[("authorization", &bearer), ("content-type", "application/json")],
        r#"{"text":"From the editor."}"#,
    );
    assert_eq!(status, 200, "{body}");
    assert!(text(&run(d, &["brief", "show"])).contains("From the editor."));

    // No token, a wrong one, a web page's Origin, or another Host: refused.
    assert_eq!(http(&url, "GET", "/api/v1/brief", &[], "").0, 401);
    assert_eq!(http(&url, "GET", "/api/v1/brief", &[("authorization", "Bearer nope")], "").0, 401);
    assert_eq!(http(&url, "GET", "/api/v1/brief", &[("authorization", &bearer), ("origin", "http://evil.example")], "").0, 403);
    assert_eq!(http(&url, "GET", "/api/v1/brief", &[("authorization", &bearer), ("host", "evil.example")], "").0, 403);

    // It ends when its input closes.
    drop(child.stdin.take());
    let status = tokio::task::spawn_blocking(move || child.wait()).await.unwrap().unwrap();
    assert!(status.success());
    srv.stop();
}