use crate::service::message::{NodeAnnouncement, RefsAnnouncement};

use crate::service::tracking::{store::Write, Scope};

use crate::storage;

use crate::storage::{Namespaces, ReadStorage};

use crate::worker::fetch;

use crate::worker::FetchError;

use crate::Link;

#[derive(thiserror::Error, Debug)]

pub enum Error {

    #[error(transparent)]

    Storage(#[from] storage::Error),

    #[error(transparent)]

    Refs(#[from] storage::refs::Error),

        }

    }

    /// Initiate an outgoing fetch for some repository.

    fn fetch(&mut self, rid: Id, from: &NodeId, timeout: time::Duration) {

        let Some(session) = self.sessions.get_mut(from) else {

            error!(target: "service", "Session {from} does not exist; cannot initiate fetch");

            return;

            }

            session::FetchResult::Ready => {

                debug!(target: "service", "Fetch initiated for {rid} with {seed}..");

                match self.tracking.namespaces_for(&self.storage, &rid) {

                    Ok(namespaces) => {

                    }

                    Err(err) => {

                        error!(target: "service", "Error getting namespaces for {rid}: {err}");

        if timestamp.saturating_sub(now.as_millis()) > MAX_TIME_DELTA.as_millis() as u64 {

            return Err(session::Error::InvalidTimestamp(timestamp));

        }

        // Discard announcement messages we've already seen, otherwise update out last seen time.

        match self.gossip.announced(announcer, announcement) {

            Ok(fresh) => {

                                }

                                Ok(false) => {

                                    debug!(target: "service", "Missing tracked inventory {id}; initiating fetch..");

                                    self.fetch(*id, announcer, FETCH_TIMEOUT);

                                }

                                Err(e) => {

                    // which is required by the protocol to only announce refs it has.

                    if self.sessions.is_connected(announcer) {

                        match self.should_fetch_refs_announcement(message, &repo_entry.scope) {

                            Err(e) => {

                                error!(target: "service", "Failed to check refs announcement: {e}");

                                return Err(session::Error::Misbehavior);

        &self,

        message: &RefsAnnouncement,

        scope: &tracking::Scope,

        // First, check the freshness.

        if !message.is_fresh(&self.storage)? {

            debug!(target: "service", "All refs of {} are already in local storage", &message.rid);

        }

        // Second, check the scope.

        match scope {

            tracking::Scope::Trusted => {

                match self.tracking.namespaces_for(&self.storage, &message.rid) {

                    Ok(Namespaces::Trusted(mut trusted)) => {

                        // Get the set of trusted nodes except self.

                        trusted.remove(&self.node_id());

                        // Check if there is at least one trusted ref.

                    }

                    Err(NamespacesError::NoTrusted { rid }) => {

                        debug!(target: "service", "No trusted nodes to fetch {}", &rid);

                    }

                    Err(e) => {

                        error!(target: "service", "Failed to obtain namespaces: {e}");

        let mut refs = BoundedVec::<_, REF_REMOTE_LIMIT>::new();

        for remote_id in remotes.into_iter() {

                warn!(

                    target: "service",

                    "refs announcement limit ({}) exceeded, peers will see only some of your repository references",

use std::time;

use log::*;

use crate::prelude::*;

use crate::service::session::Session;

        remote: NodeId,

        /// Namespaces being fetched.

        namespaces: Namespaces,

        /// Fetch timeout.

        timeout: time::Duration,

    },

        remote: &mut Session,

        rid: Id,

        namespaces: Namespaces,

        timeout: time::Duration,

    ) {

        self.io.push_back(Io::Fetch {

            rid,

            namespaces,

            remote: remote.id,

            timeout,

        });

use std::{fmt, io, mem};

use crate::crypto;

use crate::identity::Id;

use crate::node;

use crate::node::{Address, Alias};

use crate::service::filter::Filter;

use crate::service::{Link, NodeId, Timestamp};

use crate::storage;

use crate::wire;

/// Maximum number of addresses which can be announced to other nodes.

pub const ADDRESS_LIMIT: usize = 16;

/// Maximum number of repository remotes that can be included in a [`RefsAnnouncement`] message.

/// Maximum number of inventory which can be announced to other nodes.

pub const INVENTORY_LIMIT: usize = 2973;

pub struct RefsAnnouncement {

    /// Repository identifier.

    pub rid: Id,

    /// Time of announcement.

    pub timestamp: Timestamp,

}

        };

        for theirs in self.refs.iter() {

                    return Ok(true);

                }

            } else {

            Ok(r) => r,

        };

        }

        Ok(false)

    }

    use crate::test::arbitrary;

    use fastrand;

    use qcheck_macros::quickcheck;

    #[test]

    fn test_ref_remote_limit() {

        let mut refs = BoundedVec::<_, REF_REMOTE_LIMIT>::new();

        let signer = MockSigner::default();

        assert_eq!(refs.capacity(), REF_REMOTE_LIMIT);

        for _ in 0..refs.capacity() {

        }

        let msg: Message = AnnouncementMessage::from(RefsAnnouncement {

    }

    #[quickcheck]

        let signer = MockSigner::new(&mut fastrand::Rng::new());

        let timestamp = 0;

        let message = AnnouncementMessage::Refs(RefsAnnouncement {

            rid,

            refs,

use radicle::node::address::Store;

use radicle::node::{address, Alias, ConnectOptions};

use radicle::rad;

use radicle::storage::{ReadRepository, RemoteRepository};

use radicle::Storage;

        if let Ok(repo) = self.storage().repository(rid) {

            if let Ok(false) = repo.is_empty() {

                if let Ok(remotes) = repo.remotes() {

                        }

                    }

                }

use radicle::identity::Visibility;

use radicle::node::routing::Store as _;

use radicle::node::{ConnectOptions, DEFAULT_TIMEOUT};

use crate::collections::{RandomMap, RandomSet};

use crate::crypto::test::signer::MockSigner;

use crate::test::peer::Peer;

use crate::test::simulator;

use crate::test::simulator::{Peer as _, Simulation};

use crate::test::storage::MockStorage;

use crate::wire::Decode;

use crate::wire::Encode;

    let mut alice = Peer::with_storage("alice", [7, 7, 7, 7], storage_alice);

    let mut bob = Peer::with_storage("bob", [8, 8, 8, 8], storage_bob);

    // Generate some refs for Bob under their own node_id.

    let refs = arbitrary::gen::<Refs>(8);

    let signed_refs = refs.signed(bob.signer()).unwrap();

    let node_id = bob.id;

    // Alice uses Scope::Trusted, and did not track Bob yet.

    alice.connect_to(&bob);

    let bob = Peer::new("eve", [9, 9, 9, 9]);

    let acme = alice.project("acme", "");

    let events = alice.events();

    let ann = AnnouncementMessage::from(RefsAnnouncement {

        rid: acme,

        timestamp: bob.timestamp(),

    });

    let msg = ann.signed(bob.signer());

use crate::prelude::*;

use crate::service::filter;

use crate::storage::refs::Refs;

use crate::storage::refs::SignedRefs;

/// The default type we use to represent sizes on the wire.

    }

}

impl Encode for node::Features {

    fn encode<W: io::Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {

        self.deref().encode(writer)

impl wire::Decode for RefsAnnouncement {

    fn decode<R: std::io::Read + ?Sized>(reader: &mut R) -> Result<Self, wire::Error> {

        let rid = Id::decode(reader)?;

        let timestamp = Timestamp::decode(reader)?;

        Ok(Self {

            } => {

                log::debug!(target: "worker", "Worker processing outgoing fetch for {}", rid);

                let result = self.fetch(rid, remote, channels);

                FetchResult::Initiator { rid, result }

            }

            FetchRequest::Responder { remote } => {

    }

}

/// Verified [`SignedRefs`] that keeps track of their content address

/// [`Oid`].

#[derive(Debug, Clone, PartialEq, Eq)]

use crate::node::address::AddressType;

use crate::node::{Address, Alias};

use crate::storage;

use crate::test::storage::{MockRepository, MockStorage};

use crate::{cob, git};

    }

}

impl Arbitrary for MockStorage {

    fn arbitrary(g: &mut qcheck::Gen) -> Self {

        let inventory = Arbitrary::arbitrary(g);

    /// All refs keyed by RID.

    /// Each value is a map of refs keyed by node Id (public key).

}

impl MockStorage {

    }

    /// Add a remote `node` with `signed_refs` for the repo `rid`.

        self.remotes

            .entry(rid)

            .or_insert(HashMap::new())

    }

}

pub struct MockRepository {

    id: Id,

    doc: DocAt,

}

impl MockRepository {

    fn remote(&self, id: &RemoteId) -> Result<Remote<Verified>, refs::Error> {

        self.remotes

            .get(id)

            .ok_or(refs::Error::InvalidRef)

    }

        Ok(self

            .remotes

            .iter()

            .collect())

    }

}

    fn reference_oid(

        &self,

    ) -> Result<git_ext::Oid, git::raw::Error> {

    }

    fn references_of(&self, _remote: &RemoteId) -> Result<crate::storage::refs::Refs, Error> {