//! The instance's word for its TLS certificate (spec §8.6): the

//! `instance.tls` event the daemon signs with the instance key, and the

//! check a client makes of it.

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

use serde_json::{json, Value as Json};

use spectra_core::event::Event;

use spectra_core::identity::Identity;

use spectra_core::keys::KeyPair;

use spectra_core::ledger::Ledger;

use spectra_core::proof::Proof;

/// The latest `instance.tls` event, if any.

pub async fn latest_tls(ledger: &Ledger) -> Result<Option<Event>> {

    let mut last = None;

    let mut from = 1;

    loop {

        let rows = ledger.events_of_kinds(from, &["instance.tls"], 1000).await?;

        match rows.last() {

            Some(e) => {

                from = e.seq + 1;

                last = Some(e.clone());

            }

            None => return Ok(last),

        }

    }

}

/// Record the certificate's pin, signed by the instance key, unless the

/// latest record already names it.

pub async fn record_tls(ledger: &Ledger, instance: &KeyPair, spki: &[u8; 32], names: &[String]) -> Result<bool> {

    let hex_spki = hex::encode(spki);

    if let Some(e) = latest_tls(ledger).await? {

        if e.json().get("spki_sha256").and_then(Json::as_str) == Some(hex_spki.as_str()) {

            return Ok(false);

        }

    }

    let payload = json!({ "spki_sha256": hex_spki, "names": names });

    ledger.append_one(spectra_core::principals::signed_event(instance, "system", "instance.tls", payload)).await?;

    Ok(true)

}

/// What `GET /api/v1/instance` told a client, checked.

#[derive(Clone, Debug)]

pub struct Checked {

    pub name: String,

    pub instance: Identity,

    pub owner: Option<String>,

    /// The certificate the instance key vouches for.

    pub spki_sha256: [u8; 32],

}

/// Check `/api/v1/instance`'s answer: the identity is whole, and the

/// instance key signed an `instance.tls` naming the certificate `seen`.

pub fn check(answer: &Json, seen: &[u8; 32]) -> Result<Checked> {

    let ip = answer.get("instance").context("no instance in the answer")?;

    let bytes = ip.get("identity").and_then(Json::as_str).and_then(|h| hex::decode(h).ok()).context("no instance identity")?;

    let instance = Identity::decode(&bytes).map_err(|e| anyhow::anyhow!("malformed instance identity: {e}"))?;

    let tls = answer.get("tls").filter(|t| !t.is_null()).context("the server has not signed a TLS certificate")?;

    let payload = tls.get("payload").context("no TLS payload")?;

    let proof = tls.get("proof").and_then(Json::as_str).and_then(|h| hex::decode(h).ok()).context("no TLS proof")?;

    let proof = Proof::decode(&proof).map_err(|e| anyhow::anyhow!(e))?;

    if proof.key() != instance.hash().0 || proof.method != "cli" {

        bail!("the certificate is not vouched for by the instance key");

    }

    proof

        .verify(&instance, Some(&spectra_core::event::canonical_json(payload)))

        .map_err(|e| anyhow::anyhow!("the instance's signature on its certificate: {e}"))?;

    let named = payload.get("spki_sha256").and_then(Json::as_str).context("no pin in the TLS record")?;

    if named != hex::encode(seen) {

        bail!("the server presented a certificate its instance key did not sign");

    }

    Ok(Checked {

        name: answer.get("name").and_then(Json::as_str).unwrap_or("").to_string(),

        instance,

        owner: answer.get("owner").and_then(Json::as_str).map(String::from),

        spki_sha256: *seen,

    })

}