//! `spectra open`: sign in to Radar (spec §8.3). The owner's CLI signs a

//! request for a one-time link with the owner's key; the link, valid for a

//! minute, opens a level-2 browser session.

use super::identity::{owner_home, recorded_owner};

use super::{ui, Ctx};

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

use spectra_core::ledger::Ledger;

use spectra_mcp::client::Client;

use std::path::PathBuf;

/// The sign-in link, landing on `page` if one is named.

fn with_page(url: String, page: Option<&str>) -> String {

    match page.filter(|p| !p.is_empty() && *p != "live") {

        Some(p) => format!("{url}&next={}", p.trim_start_matches('/')),

        None => url,

    }

}

pub async fn open(ctx: &Ctx, owner_home_flag: Option<PathBuf>, launch: bool, page: Option<&str>) -> Result<i32> {

    let socket = ctx.socket();

    if !Client::alive(&socket).await {

        bail!("Spectra is not serving {} (spectra serve)", ctx.data.display());

    }

    let home = owner_home(ctx, owner_home_flag);

    let ledger = Ledger::open_read_only(&ctx.db()?).await?;

    let owner = recorded_owner(&ledger, &home).await?;

    let r = Client::new(&socket, Some(owner)).send("POST", "/radar/link", &[], Vec::new()).await?;

    if r.status != 200 {

        bail!("the daemon refused the sign-in: {}", String::from_utf8_lossy(&r.body));

    }

    let url = r.json()?.get("url").and_then(|u| u.as_str()).map(String::from).context("no link in the answer")?;

    let url = with_page(url, page);

    println!("{} {}", ui::done("Signed"), ui::subject("a one-time link to Radar, good for a minute"));

    show(&url, launch);

    Ok(0)

}

fn show(url: &str, launch: bool) {

    println!("  {}", ui::id(url));

    if launch

        && std::process::Command::new("xdg-open")

            .arg(url)

            .stdout(std::process::Stdio::null())

            .stderr(std::process::Stdio::null())

            .spawn()

            .is_ok()

    {

        println!("  {} {}", ui::note(), ui::dim("opened in your browser"));

    }

}

/// `spectra open` with Spectra on another machine (spec §8.6): serve Radar

/// through a loopback proxy to the pinned server, and sign in through it.

pub async fn open_remote(ctx: &Ctx, owner_home_flag: Option<PathBuf>, launch: bool, port: u16, page: Option<&str>) -> Result<i32> {

    let cfg = ctx.remote()?.context("no server configured")?;

    let home = owner_home(ctx, owner_home_flag);

    let listener = tokio::net::TcpListener::bind(("127.0.0.1", port))

        .await

        .with_context(|| format!("binding 127.0.0.1:{port} for Radar (another `spectra open` running? --port picks another)"))?;

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

    let client = ctx.owner_client(&home).await?.context("no server configured")?;

    let r = client.send("POST", "/radar/link", &[], Vec::new()).await?;

    if r.status != 200 {

        bail!("the server refused the sign-in: {}", String::from_utf8_lossy(&r.body));

    }

    let url = r.json()?.get("url").and_then(|u| u.as_str()).map(String::from).context("no link in the answer")?;

    let local = with_page(spectra_mcp::proxy::local_link(&url, port), page);

    println!("{} {}{}{}", ui::done("Serving"), ui::subject("Radar"), ui::sep(), ui::dim(format!("from {} over pinned TLS", cfg.server)));

    println!("{}", ui::kv("radar", format!("http://127.0.0.1:{port}")));

    println!("{} {}", ui::done("Signed"), ui::subject("a one-time link, good for a minute"));

    show(&local, launch);

    println!("  {} {}", ui::note(), ui::dim("Ctrl-C stops the proxy"));

    use std::io::Write;

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

    let app = spectra_mcp::proxy::router(cfg.endpoint()?, port);

    axum::serve(listener, app)

        .with_graceful_shutdown(async {

            let _ = tokio::signal::ctrl_c().await;

        })

        .await?;

    Ok(0)

}