//! Keys and identities on disk, laid out exactly as `oxy` lays them out

//! (spec §8.1, §21.3): an `OXY_HOME` holds `keys/<KEYID>.secret` (private),

//! `keys/<KEYID>.identity` and `config.toml` naming the key as `author.key`.

//! Spectra writes them with `oxy-core`'s own functions, so `oxy` reads what

//! Spectra made and the other way round.

//!

//! The instance key (spec §9.5) is kept in the data directory instead, at

//! `keys/instance.secret` and `keys/instance.identity`.

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

use oxy_core::durable::{write_atomic, write_atomic_private};

use oxy_core::hash::KeyId;

use oxy_core::identity::{Identity, SecretKey, Signature};

use std::fs;

use std::path::{Path, PathBuf};

/// A key pair with its identity: the instance, an agent, or the owner.

#[derive(Clone, Debug)]

pub struct KeyPair {

    pub key: KeyId,

    pub identity: Identity,

    secret: SecretKey,

}

impl KeyPair {

    /// A fresh key pair named `name`, made now.

    pub fn generate(name: &str, email: &str) -> KeyPair {

        let secret = SecretKey::generate();

        let identity = secret.identity(name, email, crate::ids::now_ms());

        KeyPair { key: identity.hash(), identity, secret }

    }

    /// Sign `message` (a Spectra domain-prefixed byte string, at least 16

    /// bytes) through Oxygen's challenge signing: the target is

    /// `BLAKE3("oxy1 challenge " || message)`, so a Spectra signature can

    /// never be taken for a change, an attestation or a policy.

    pub fn sign(&self, message: &[u8]) -> Signature {

        self.secret.sign_challenge(&self.key, message).expect("Spectra messages are longer than 16 bytes")

    }

    /// Make a key pair in an `OXY_HOME` laid out as `oxy identity create`

    /// lays one out, and name it the home's author.

    pub fn create_home(home: &Path, name: &str, email: &str) -> Result<KeyPair> {

        let pair = KeyPair::generate(name, email);

        let keys = home.join("keys");

        fs::create_dir_all(&keys).with_context(|| format!("creating {}", keys.display()))?;

        #[cfg(unix)]

        {

            use std::os::unix::fs::PermissionsExt;

            fs::set_permissions(home, fs::Permissions::from_mode(0o700))?;

        }

        write_atomic_private(&keys.join(format!("{}.secret", pair.key.to_hex())), &pair.secret.encode(&pair.key))?;

        write_atomic(&keys.join(format!("{}.identity", pair.key.to_hex())), &pair.identity.encode())?;

        let config = home.join("config.toml");

        oxy_core::repo::Config::set_user(&config, "author.name", name)?;

        oxy_core::repo::Config::set_user(&config, "author.email", email)?;

        oxy_core::repo::Config::set_user(&config, "author.key", &pair.key.to_hex())?;

        Ok(pair)

    }

    /// The key pair an `OXY_HOME` signs with: `author.key` from its

    /// `config.toml`, else its only secret key.

    pub fn load_home(home: &Path) -> Result<KeyPair> {

        let keys = home.join("keys");

        let key = match author_key(home)? {

            Some(k) => k,

            None => {

                let secrets: Vec<PathBuf> = fs::read_dir(&keys)

                    .with_context(|| format!("reading {}", keys.display()))?

                    .filter_map(|e| e.ok().map(|e| e.path()))

                    .filter(|p| p.extension().is_some_and(|x| x == "secret"))

                    .collect();

                match secrets.as_slice() {

                    [one] => KeyId::from_hex(one.file_stem().and_then(|s| s.to_str()).unwrap_or(""))

                        .context("a secret key file is not named by its key")?,

                    [] => bail!("{} holds no secret key: an agent home is made by `spectra agent add`", home.display()),

                    _ => bail!("{} holds several keys and its config.toml names none (author.key)", home.display()),

                }

            }

        };

        KeyPair::load(&keys.join(format!("{}.secret", key.to_hex())), &keys.join(format!("{}.identity", key.to_hex())))

    }

    /// Read a secret and its identity, checking that they belong together.

    pub fn load(secret: &Path, identity: &Path) -> Result<KeyPair> {

        let (key, secret_key) = SecretKey::decode(&fs::read(secret).with_context(|| format!("reading {}", secret.display()))?)

            .map_err(|e| anyhow::anyhow!("{}: {e}", secret.display()))?;

        let identity = Identity::decode(&fs::read(identity).with_context(|| format!("reading {}", identity.display()))?)

            .map_err(|e| anyhow::anyhow!("{}: {e}", identity.display()))?;

        if identity.hash() != key {

            bail!("{} is not the identity of {}", identity.name, secret.display());

        }

        if secret_key.identity(&identity.name, &identity.email, identity.created).ed25519_pk != identity.ed25519_pk {

            bail!("the secret key in {} does not match its identity", secret.display());

        }

        Ok(KeyPair { key, identity, secret: secret_key })

    }

    /// The data directory's instance key, made on first use (spec §9.5).

    pub fn instance(data: &Path, name: &str) -> Result<KeyPair> {

        let keys = data.join("keys");

        let (secret, identity) = (keys.join("instance.secret"), keys.join("instance.identity"));

        if secret.exists() {

            return KeyPair::load(&secret, &identity);

        }

        fs::create_dir_all(&keys)?;

        let pair = KeyPair::generate(name, "");

        write_atomic_private(&secret, &pair.secret.encode(&pair.key))?;

        write_atomic(&identity, &pair.identity.encode())?;

        Ok(pair)

    }

}

/// The identity an `OXY_HOME` names as its author (`oxy identity export`

/// without the CLI): for reading the owner's identity at `spectra init`.

pub fn home_identity(home: &Path) -> Result<Identity> {

    let key = author_key(home)?.with_context(|| format!("{} names no identity (author.key in config.toml)", home.display()))?;

    let path = home.join("keys").join(format!("{}.identity", key.to_hex()));

    Identity::decode(&fs::read(&path).with_context(|| format!("reading {}", path.display()))?)

        .map_err(|e| anyhow::anyhow!("{}: {e}", path.display()))

}

fn author_key(home: &Path) -> Result<Option<KeyId>> {

    let config = home.join("config.toml");

    let Ok(text) = fs::read_to_string(&config) else { return Ok(None) };

    let table: toml::Table = text.parse().with_context(|| format!("reading {}", config.display()))?;

    let found = table.get("author").and_then(|a| a.get("key")).or_else(|| table.get("author.key")).and_then(|v| v.as_str());

    Ok(match found {

        Some(hex) => Some(KeyId::from_hex(hex).with_context(|| format!("{}: author.key is not a key", config.display()))?),

        None => None,

    })

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn a_home_made_here_reads_back_and_signs_verifiably() {

        let dir = tempfile::tempdir().unwrap();

        let made = KeyPair::create_home(dir.path(), "claude-oxygen", "").unwrap();

        let read = KeyPair::load_home(dir.path()).unwrap();

        assert_eq!(made.key, read.key);

        assert_eq!(home_identity(dir.path()).unwrap().hash(), made.key);

        let msg = b"spectra1 test message of some length";

        let sig = read.sign(msg);

        oxy_core::identity::verify_challenge(&made.identity, &sig, msg).unwrap();

        assert!(oxy_core::identity::verify_challenge(&made.identity, &sig, b"spectra1 another message entirely").is_err());

    }

    #[test]

    fn the_instance_key_is_made_once() {

        let dir = tempfile::tempdir().unwrap();

        let a = KeyPair::instance(dir.path(), "laptop").unwrap();

        let b = KeyPair::instance(dir.path(), "laptop").unwrap();

        assert_eq!(a.key, b.key);

    }

}