//! Trust policy management and enforcement (spec §14.5).

//!

//! A repository with a policy verifies everything it receives: every change

//! must be authenticated by a key the policy authorizes for the bookmark,

//! every bookmark update must carry an attestation by such a key, and a new

//! policy must be signed by a threshold of the roots of the policy it replaces.

use super::*;

use crate::identity::SecretKey;

use crate::policy::{Policy, Require, Rule};

use crate::protocol::SignedPolicy;

/// One year, the default policy lifetime.

const POLICY_LIFETIME_MS: u64 = 365 * 24 * 60 * 60 * 1000;

/// A signed policy update: applied when it met the root threshold, else a

/// proposal carrying the signatures gathered so far (spec §14.5).

#[derive(Clone, Debug)]

pub struct PolicyUpdate {

    pub policy: Policy,

    pub sigs: Vec<Signature>,

    pub applied: bool,

}

impl PolicyUpdate {

    pub fn signed(&self) -> SignedPolicy {

        SignedPolicy {

            policy: self.policy.clone(),

            sigs: self.sigs.clone(),

        }

    }

}

impl Repo {

    /// The current policy and its signatures, if the repository has one.

    pub fn current_policy(&self) -> Result<Option<(ObjectRef, SignedPolicy)>> {

        let Some(r) = self.view()?.policy else {

            return Ok(None);

        };

        let policy = Policy::decode(&self.store.get_typed(&r, ObjectType::Policy)?)?;

        Ok(Some((

            r,

            SignedPolicy {

                policy,

                sigs: self.store.signatures(&r)?,

            },

        )))

    }

    /// Store a policy with its signatures and point the `policy` reference at it.

    pub(crate) fn set_policy(&self, sp: &SignedPolicy, command: &str) -> Result<ObjectRef> {

        let r = self.store.put(ObjectType::Policy, &sp.policy.encode())?;

        for sig in &sp.sigs {

            self.store.put_signature(&r, sig)?;

        }

        for id in &sp.policy.identities {

            self.store.put_identity(id)?;

        }

        let dir = self.oxy.join("policies");

        fs::create_dir_all(&dir)?;

        write_atomic(

            &dir.join(format!("{:020}", sp.policy.serial)),

            r.to_hex().as_bytes(),

        )?;

        let (op_ref, op) = self.head_op()?;

        if op.view.policy != Some(r) {

            let mut view = op.view.clone();

            view.policy = Some(r);

            self.record_op(&[op_ref], command, view)?;

        }

        Ok(r)

    }

    /// Every policy this repository has applied, ascending by serial, with

    /// its signatures. Policies applied before this index existed are

    /// missing from it, except the current one.

    pub fn policy_history(&self) -> Result<Vec<SignedPolicy>> {

        let mut out: BTreeMap<u64, SignedPolicy> = BTreeMap::new();

        if let Ok(rd) = fs::read_dir(self.oxy.join("policies")) {

            for e in rd.flatten() {

                let Ok(hex) = fs::read_to_string(e.path()) else {

                    continue;

                };

                let Some(r) = ObjectRef::from_hex(hex.trim()) else {

                    continue;

                };

                let Ok(bytes) = self.store.get_typed(&r, ObjectType::Policy) else {

                    continue;

                };

                let policy = Policy::decode(&bytes)?;

                out.insert(

                    policy.serial,

                    SignedPolicy {

                        policy,

                        sigs: self.store.signatures(&r)?,

                    },

                );

            }

        }

        if let Some((_, sp)) = self.current_policy()? {

            out.insert(sp.policy.serial, sp);

        }

        Ok(out.into_values().collect())

    }

    /// Verify and apply a chain of policies ending in `newest`, each

    /// against the one before it (spec §14.5). `chain` holds earlier

    /// policies in any order; only those after the current serial are used.

    pub(crate) fn adopt_policy_chain(

        &self,

        chain: &[SignedPolicy],

        newest: &SignedPolicy,

        command: &str,

    ) -> std::result::Result<(), String> {

        let mut current = self

            .current_policy()

            .map_err(|e| e.to_string())?

            .map(|(_, sp)| sp.policy);

        let mut steps: Vec<&SignedPolicy> = chain

            .iter()

            .filter(|sp| {

                current.as_ref().is_none_or(|c| sp.policy.serial > c.serial)

                    && sp.policy.serial < newest.policy.serial

            })

            .collect();

        steps.sort_by_key(|sp| sp.policy.serial);

        steps.push(newest);

        for sp in steps {

            self.check_policy(sp, current.as_ref())?;

            self.set_policy(

                sp,

                &format!("{command} (policy serial {})", sp.policy.serial),

            )

            .map_err(|e| e.to_string())?;

            current = Some(sp.policy.clone());

        }

        Ok(())

    }

    /// Validate an incoming policy against the one we trust (`None` when

    /// bootstrapping: the policy then vouches for itself).

    pub fn check_policy(

        &self,

        sp: &SignedPolicy,

        trusted: Option<&Policy>,

    ) -> std::result::Result<(), String> {

        if sp.policy.repo != self.id().map_err(|e| e.to_string())? {

            return Err("policy is for a different repository".into());

        }

        if let Some(t) = trusted {

            if sp.policy.serial <= t.serial {

                return Err(format!(

                    "policy serial {} is not greater than the current {}",

                    sp.policy.serial, t.serial

                ));

            }

        }

        match trusted {

            Some(t) => sp.policy.verify_signatures(&sp.sigs, t)?,

            None => vec![sp.policy.verify_bootstrap(&sp.sigs)?],

        };

        Ok(())

    }

    /// Sign `policy` with the configured key and apply it if the current

    /// policy's root threshold is met; otherwise return it as a proposal.

    fn sign_policy(&self, policy: Policy, command: &str) -> Result<PolicyUpdate> {

        let Some((key, sk)) = self.secret_key()? else {

            return fail("no secret key: run `oxy identity create` first");

        };

        self.sign_policy_with(policy, &[(key, &sk)], command)

    }

    /// Sign with every listed key; the first must be a root of the current

    /// policy (the others may be roots of the new policy only, so that a

    /// fresh clone can bootstrap from it).

    pub(crate) fn sign_policy_with(

        &self,

        policy: Policy,

        signers: &[(KeyId, &SecretKey)],

        command: &str,

    ) -> Result<PolicyUpdate> {

        let trusted = self

            .current_policy()?

            .map(|(_, sp)| sp.policy)

            .unwrap_or_else(|| policy.clone());

        if !signers

            .first()

            .is_some_and(|(k, _)| trusted.roots.contains(k))

        {

            return fail("your key is not a root key of the current policy");

        }

        let target = policy.hash();

        let sigs = signers

            .iter()

            .map(|(k, sk)| sk.sign(Domain::Policy, k, &target))

            .collect();

        self.gather(SignedPolicy { policy, sigs }, &trusted, command)

    }

    /// Apply `sp` when its signatures meet `trusted`'s threshold.

    fn gather(&self, sp: SignedPolicy, trusted: &Policy, command: &str) -> Result<PolicyUpdate> {

        let applied = sp.policy.verify_signatures(&sp.sigs, trusted).is_ok();

        if applied {

            self.set_policy(&sp, command)?;

        }

        Ok(PolicyUpdate {

            policy: sp.policy,

            sigs: sp.sigs,

            applied,

        })

    }

    /// Add your signature to a proposal made by another root holder; the

    /// policy is applied once the current root threshold is met.

    pub fn policy_sign(&self, proposal: SignedPolicy) -> Result<PolicyUpdate> {

        let Some((key, sk)) = self.secret_key()? else {

            return fail("no secret key: run `oxy identity create` first");

        };

        let Some((_, current)) = self.current_policy()? else {

            return fail("this repository has no policy; run `oxy policy init` or fetch one");

        };

        if proposal.policy.repo != self.id()? {

            return fail("the proposal is for a different repository");

        }

        if proposal.policy.serial <= current.policy.serial {

            return fail(format!(

                "the proposal's serial {} is not greater than the current {}",

                proposal.policy.serial, current.policy.serial

            ));

        }

        if !current.policy.roots.contains(&key) {

            return fail("your key is not a root key of the current policy");

        }

        let mut sigs: Vec<Signature> = proposal.sigs.into_iter().filter(|s| s.key != key).collect();

        sigs.push(sk.sign(Domain::Policy, &key, &proposal.policy.hash()));

        self.gather(

            SignedPolicy {

                policy: proposal.policy,

                sigs,

            },

            &current.policy,

            "oxy policy sign",

        )

    }

    /// Create the initial policy with the configured identity as sole root.

    pub fn policy_init(&self) -> Result<PolicyUpdate> {

        if self.current_policy()?.is_some() {

            return fail("this repository already has a policy");

        }

        let Some((key, _)) = self.secret_key()? else {

            return fail("no secret key: run `oxy identity create` first");

        };

        let identity = self.identity(&key)?;

        let policy = Policy::single_root(

            self.id()?,

            identity,

            Hlc::now().wall_ms + POLICY_LIFETIME_MS,

        );

        self.sign_policy(policy, "oxy policy init")

    }

    /// Make `identity` a root key.

    pub fn policy_root_add(&self, identity: Identity) -> Result<PolicyUpdate> {

        let mut p = self.next_policy()?;

        let key = identity.hash();

        if p.roots.contains(&key) {

            return fail(format!("{} is already a root", key.short(12)));

        }

        p.roots.push(key);

        p.roots.sort();

        p.revoked.retain(|k| k != &key);

        if p.identity(&key).is_none() {

            p.identities.push(identity);

        }

        self.sign_policy(p, &format!("oxy policy root add {}", key.short(12)))

    }

    /// Drop a root key; the remaining roots must still meet the threshold.

    pub fn policy_root_remove(&self, key: &KeyId) -> Result<PolicyUpdate> {

        let mut p = self.next_policy()?;

        if !p.roots.contains(key) {

            return fail(format!("{} is not a root", key.short(12)));

        }

        p.roots.retain(|k| k != key);

        if (p.roots.len() as u32) < p.root_threshold {

            return fail(format!(

                "removing it would leave {} root(s) for a threshold of {}",

                p.roots.len(),

                p.root_threshold

            ));

        }

        self.sign_policy(p, &format!("oxy policy root remove {}", key.short(12)))

    }

    /// Require `n` root signatures on future policy updates.

    pub fn policy_set_threshold(&self, n: u32) -> Result<PolicyUpdate> {

        let mut p = self.next_policy()?;

        if n == 0 || n as usize > p.roots.len() {

            return fail(format!(

                "the threshold must be between 1 and the number of roots ({})",

                p.roots.len()

            ));

        }

        p.root_threshold = n;

        self.sign_policy(p, &format!("oxy policy root threshold {n}"))

    }

    pub(crate) fn next_policy(&self) -> Result<Policy> {

        let Some((_, sp)) = self.current_policy()? else {

            return fail("this repository has no policy; run `oxy policy init`");

        };

        let mut p = sp.policy;

        p.serial += 1;

        p.expires = Hlc::now().wall_ms + POLICY_LIFETIME_MS;

        Ok(p)

    }

    /// Let `identity` update references matching `pattern` (default every reference).

    pub fn policy_grant(&self, identity: Identity, pattern: Option<&str>) -> Result<PolicyUpdate> {

        let mut p = self.next_policy()?;

        let key = identity.hash();

        let pattern = pattern.unwrap_or("*");

        p.revoked.retain(|k| k != &key);

        match p.rules.iter_mut().find(|r| r.pattern == pattern) {

            Some(rule) => {

                if !rule.keys.contains(&key) {

                    rule.keys.push(key);

                    rule.keys.sort();

                }

            }

            None => p.rules.push(Rule {

                pattern: pattern.into(),

                keys: vec![key],

                threshold: 1,

                require: Require::Any,

                allow_conflicts: true,

            }),

        }

        if p.identity(&key).is_none() {

            p.identities.push(identity);

        }

        self.sign_policy(p, &format!("oxy policy grant {}", key.short(12)))

    }

    /// Revoke `key`: it may no longer update anything, and existing rules

    /// drop it. A root key can be revoked by another root as long as the

    /// remaining roots still meet the threshold.

    pub fn policy_revoke(&self, key: &KeyId) -> Result<PolicyUpdate> {

        let mut p = self.next_policy()?;

        if p.roots.contains(key) {

            let own = self.secret_key()?.map(|(k, _)| k);

            if own == Some(*key) {

                return fail("a root cannot revoke itself; have another root revoke it, or remove it with `oxy policy root remove` first");

            }

            p.roots.retain(|k| k != key);

            if (p.roots.len() as u32) < p.root_threshold {

                return fail(format!(

                    "revoking it would leave {} root(s) for a threshold of {}",

                    p.roots.len(),

                    p.root_threshold

                ));

            }

        }

        for r in &mut p.rules {

            r.keys.retain(|k| k != key);

        }

        p.rules.retain(|r| !r.keys.is_empty());

        if !p.revoked.contains(key) {

            p.revoked.push(*key);

            p.revoked.sort();

        }

        self.sign_policy(p, &format!("oxy policy revoke {}", key.short(12)))

    }

    /// Whether `change` may be part of `reference` under `policy`: it must be

    /// authenticated (by its author or a delegate) with a key the matching

    /// rule lists, using the authenticator kind the rule requires. A rule key

    /// covers its rotation predecessors, and a delegate's signature counts

    /// for the author it acts for.

    pub fn change_allowed(

        &self,

        hash: &ChangeHash,

        policy: &Policy,

        reference: &str,

    ) -> std::result::Result<(), String> {

        let rule = policy

            .rule_for(reference)

            .ok_or_else(|| format!("no policy rule matches {reference:?}"))?;

        match self.authenticate_change(hash).map_err(|e| e.to_string())? {

            SignatureStatus::Valid { key, sealed, .. } => {

                if policy.is_revoked(&key) {

                    return Err(format!(

                        "change {} is signed by revoked key {}",

                        hash.short(12),

                        key.short(12)

                    ));

                }

                let author = self

                    .store

                    .get_change(hash)

                    .map(|c| c.author)

                    .map_err(|e| e.to_string())?;

                let principal = if author.is_zero() { key } else { author };

                let covered = rule

                    .keys

                    .iter()

                    .any(|k| policy.succeeds(k, &key) || policy.succeeds(k, &principal));

                if !covered {

                    return Err(format!(

                        "change {} is signed by {}, which may not update {reference:?}",

                        hash.short(12),

                        key.short(12)

                    ));

                }

                match (rule.require, sealed) {

                    (Require::Signed, true) => Err(format!(

                        "{reference:?} requires individually signed changes; {} is only sealed",

                        hash.short(12)

                    )),

                    (Require::Sealed, false) => Err(format!(

                        "{reference:?} requires sealed changes; {} is individually signed",

                        hash.short(12)

                    )),

                    _ => Ok(()),

                }

            }

            SignatureStatus::Unsigned => {

                Err(format!("change {} is not signed or sealed", hash.short(12)))

            }

            SignatureStatus::Invalid(e) => Err(format!("change {}: {e}", hash.short(12))),

        }

    }

    /// Check every change that `new` adds over `old` for `reference`.

    pub(crate) fn state_allowed(

        &self,

        old_heads: &[ChangeHash],

        new_heads: &[ChangeHash],

        policy: &Policy,

        reference: &str,

    ) -> std::result::Result<(), String> {

        let added = self

            .negotiate(old_heads, new_heads)

            .map_err(|e| e.to_string())?;

        for h in &added {

            self.change_allowed(h, policy, reference)?;

        }

        if let Some(rule) = policy.rule_for(reference) {

            if !rule.allow_conflicts && !added.is_empty() {

                let st = self.load_state(new_heads).map_err(|e| e.to_string())?;

                if st.materialize().is_conflicted() {

                    return Err(format!("{reference:?} does not allow conflicted states"));

                }

            }

        }

        Ok(())

    }

}