radicle 0.25.0

use std::path::Path;

use crypto::{Signer as _, SigningKey};
use crypto::{signature, signature::Keypair as _};
use qcheck::TestResult;
use qcheck_macros::quickcheck;
use radicle_core::{NodeId, RepoId};
use radicle_git_metadata::author::{Author, Time};
use radicle_oid::Oid;
use tempfile::TempDir;

use crate::git;
use crate::storage::refs::sigrefs::VerifiedCommit;
use crate::storage::refs::sigrefs::read::{SignedRefsReader, Tip};
use crate::storage::refs::sigrefs::write::{SignedRefsWriter, Update};
use crate::storage::refs::{IDENTITY_ROOT, Refs};
use crate::test::arbitrary;

use super::Committer;

type BoundedVec<T> = arbitrary::BoundedVec<T, 24>;

fn mock_author() -> Author {
    Author {
        name: "testy".to_string(),
        email: "testy@example.com".to_string(),
        time: Time::new(6400, 0),
    }
}

fn mock_committer() -> Committer {
    Committer::new(mock_author())
}

/// A helper structure that sets up a minimal Radicle repository.
struct Repository {
    raw: git::raw::Repository,
    rid: RepoId,
    root: Oid,
    _tmp: TempDir,
}

impl Repository {
    fn new() -> Repository {
        let dir = TempDir::new().unwrap();
        let repo = git::raw::Repository::init_bare(dir.path()).unwrap();
        let (root, rid) = Self::write_identity(&repo);
        Repository {
            raw: repo,
            rid,
            root,
            _tmp: dir,
        }
    }

    /// Writes a mock blob that represents the identity document, and creates a
    /// commit in the repository that contains this blob.
    fn write_identity(repo: &git::raw::Repository) -> (Oid, RepoId) {
        let blob = repo.blob(b"identity root").unwrap();
        let empty = {
            let empty = repo.treebuilder(None).unwrap();
            let tree = empty.write().unwrap();
            repo.find_tree(tree).unwrap()
        };
        let tree = {
            let mut tb = git::raw::build::TreeUpdateBuilder::new();
            tb.upsert(
                Path::new("embeds").join(*crate::identity::doc::PATH),
                blob,
                git::raw::FileMode::Blob,
            );
            let tree = tb.create_updated(repo, &empty).unwrap();
            repo.find_tree(tree).unwrap()
        };
        let author = git::raw::Signature::now("testy", "testy@example.com").unwrap();
        let root = repo
            .commit(
                Some(IDENTITY_ROOT.as_str()),
                &author,
                &author,
                "identity root",
                &tree,
                &[],
            )
            .unwrap();
        (root.into(), RepoId::from(blob))
    }
}

fn write_log(
    refs: Refs,
    rid: RepoId,
    namespace: NodeId,
    signer: &SigningKey,
    repo: &git::raw::Repository,
) -> Update {
    SignedRefsWriter::new(refs, rid, namespace, repo, signer)
        .write(
            mock_committer(),
            "test commit".to_string(),
            "test reflog".to_string(),
        )
        .unwrap()
}

fn read_log<Verifier>(
    rid: RepoId,
    namespace: NodeId,
    verifier: &Verifier,
    repo: &git::raw::Repository,
) -> VerifiedCommit
where
    Verifier: signature::Verifier<crypto::Signature>,
{
    SignedRefsReader::new(rid, Tip::Reference(namespace), repo, verifier)
        .read()
        .unwrap()
}

#[quickcheck]
fn initial_commit_roundtrip(mut refs: Refs) -> bool {
    let Repository {
        raw: repo,
        rid,
        root,
        _tmp,
    } = Repository::new();
    refs.insert(IDENTITY_ROOT.to_ref_string(), root);
    let signer = SigningKey::mock(73);
    let namespace = *signer.public_key();
    let verifier = signer.verifying_key();

    let update = write_log(refs.clone(), rid, namespace, &signer, &repo);
    let head_oid = match update {
        Update::Changed { ref entry, .. } => entry.oid(),
        Update::Unchanged { .. } => return false,
    };

    let verified_commit = read_log(rid, namespace, &verifier, &repo);
    let head = *verified_commit.commit().oid();
    let parent = verified_commit.commit().parent().copied();
    let new_refs = verified_commit.into_sigrefs_at(namespace);

    head == head_oid && parent.is_none() && *new_refs == refs
}

#[quickcheck]
fn chain_roundtrip(chain: BoundedVec<Refs>) -> TestResult {
    let chain = chain.to_vec();
    if chain.is_empty() {
        return TestResult::discard();
    }

    let Repository {
        raw: repo,
        rid,
        root,
        _tmp,
    } = Repository::new();
    let signer = SigningKey::mock(98);
    let namespace = *signer.public_key();
    let verifier = signer.verifying_key();

    let mut last_changed_head = None;
    let mut expected_parent = None;

    for mut refs in chain {
        refs.insert(IDENTITY_ROOT.to_ref_string(), root);
        let update = write_log(refs.clone(), rid, namespace, &signer, &repo);

        if let Update::Changed { ref entry, .. } = update {
            last_changed_head = Some(entry.oid());
        }

        let verified_commit = read_log(rid, namespace, &verifier, &repo);
        let head = *verified_commit.commit().oid();
        let parent = verified_commit.commit().parent().copied();
        let new_refs = verified_commit.into_sigrefs_at(namespace);

        if refs != *new_refs {
            return TestResult::failed();
        }

        if let Some(expected_head) = last_changed_head {
            if head != expected_head {
                return TestResult::error(format!(
                    "expected commit to be {expected_head}, but found {head}"
                ));
            }
            if parent != expected_parent {
                return TestResult::error(format!(
                    "expected parent commit to be {expected_parent:?}, but found {parent:?}"
                ));
            }
        }
        expected_parent = Some(head);
    }

    TestResult::passed()
}

#[quickcheck]
fn idempotent_write(mut refs: Refs) -> bool {
    let Repository {
        raw: repo,
        rid,
        root,
        _tmp,
    } = Repository::new();
    refs.insert(IDENTITY_ROOT.to_ref_string(), root);
    let signer = SigningKey::mock(83);
    let namespace = *signer.public_key();

    let first = write_log(refs.clone(), rid, namespace, &signer, &repo);
    let head_oid = match first {
        Update::Changed { ref entry, .. } => entry.oid(),
        Update::Unchanged { .. } => return false,
    };

    let second = write_log(refs, rid, namespace, &signer, &repo);
    matches!(second, Update::Unchanged { verified } if *verified.commit().oid() == head_oid)
}