//! Changes the hub makes for a signed-in user (hub spec §6.9, §6.10, §7.6):
//! built on the target state, authored by the user's linked identity,
//! signed by the hub key as that identity's delegate, and applied through
//! the same checks as a push.

use super::{RepoError, Repos};
use crate::repos::RepoName;
use oxy_core::hash::{ChangeHash, KeyId};
use oxy_core::identity::{Domain, Identity, SecretKey};
use oxy_core::repo::{FileEdit, PushReport, Repo};

type Result<T> = std::result::Result<T, RepoError>;

fn fail(msg: impl Into<String>) -> RepoError {
    RepoError::Oxy(oxy_core::repo::RepoError::Msg(msg.into()))
}

/// Who the change is for and who signs it.
pub struct Signer {
    /// The user's identity that lists the hub key as a delegate.
    pub author: Identity,
    pub hub_key: KeyId,
    pub hub_secret: SecretKey,
    pub hub_identity: Identity,
}

/// What a web edit did.
pub struct Committed {
    pub change: ChangeHash,
    pub bookmark: String,
    pub old_state: String,
    pub new_state: String,
    pub heads: Vec<ChangeHash>,
    pub report: PushReport,
}

/// Commit `edits` on top of `base_bookmark`'s state into `bookmark`
/// (the same bookmark, or a new one for a proposal).
pub async fn commit(
    repos: &Repos,
    repo: &RepoName,
    base_bookmark: String,
    bookmark: String,
    edits: Vec<FileEdit>,
    message: String,
    signer: Signer,
) -> Result<Committed> {
    repos
        .write(repo, move |r: &Repo, _| {
            let view = r.view()?;
            let base_heads = match view.bookmarks.get(&base_bookmark) {
                Some(st) => r.store().get_state(st)?.heads,
                None => return Err(fail(format!("no bookmark {base_bookmark}"))),
            };
            if bookmark != base_bookmark && view.bookmarks.contains_key(&bookmark) {
                return Err(fail(format!("bookmark {bookmark} exists; pick another name")));
            }
            let author = signer.author.hash();
            let change = r.build_change(&base_heads, &edits, &message, author)?;
            let hash = change.hash();
            let sig = signer.hub_secret.sign(Domain::Change, &signer.hub_key, &hash);
            let mut state = r.load_state(&base_heads)?;
            state.add(change.clone()).map_err(|e| fail(e.to_string()))?;
            let mut candidates = base_heads.clone();
            candidates.push(hash);
            let heads = state.maximal(&candidates);
            let update = r.host_ref_update(&bookmark, &heads, Some((&signer.hub_key, &signer.hub_secret)))?;
            let (old_state, new_state) = (update.old_state.to_hex(), update.new_state.to_hex());
            let report = r.apply_hosted(Some((change, vec![sig])), &[signer.hub_identity.clone(), signer.author.clone()], update)?;
            if let Some(refused) = report.results.iter().find(|x| !x.ok) {
                return Err(fail(format!("the repository refused the change: {}", refused.reason)));
            }
            Ok(Committed { change: hash, bookmark, old_state, new_state, heads, report })
        })
        .await
}

/// Move `bookmark` to `heads` with an attestation signed by the hub key on
/// the user's behalf (landing a proposal under a policy).
pub async fn move_bookmark(repos: &Repos, repo: &RepoName, bookmark: String, heads: Vec<ChangeHash>, signer: Signer) -> Result<PushReport> {
    repos
        .write(repo, move |r: &Repo, _| {
            let update = r.host_ref_update(&bookmark, &heads, Some((&signer.hub_key, &signer.hub_secret)))?;
            let report = r.apply_hosted(None, &[signer.hub_identity.clone(), signer.author.clone()], update)?;
            if let Some(refused) = report.results.iter().find(|x| !x.ok) {
                return Err(fail(format!("the repository refused the update: {}", refused.reason)));
            }
            Ok(report)
        })
        .await
}