willow25 0.7.0

use core::fmt::Debug;

use anyhash::Hasher;
#[cfg(feature = "dev")]
use arbitrary::Arbitrary;

use bab_rs::{HasherWrite, William3Hasher};
use compact_u64::{cu64_decode_canonic_standalone, cu64_decode_standalone};
use ufotofu::codec_prelude::*;

use crate::{authorisation::PossiblyAuthorisedEntry, groupings::Coordinatelike, prelude::*};
/// The metadata associated with each Willow [Payload](https://willowprotocol.org/specs/data-model/index.html#Payload) string.
///
/// [Entries](https://willowprotocol.org/specs/data-model/index.html#Entry) are the central concept in Willow. In order to make any bytestring of data accessible to Willow, you need to create an Entry describing its metadata. Specifically, an Entry consists of
///
/// - a [namespace_id](https://willowprotocol.org/specs/data-model/index.html#entry_namespace_id) (roughly, this addresses a universe of Willow data, fully independent from all data (i.e., Entries) of different namespace ids) of type [`NamespaceId`],
/// - a [subspace_id](https://willowprotocol.org/specs/data-model/index.html#entry_subspace_id) (roughly, a fully independent part of a namespace, typically subspaces correspond to individual users) of type [`SubspaceId`],
/// - a [path](https://willowprotocol.org/specs/data-model/index.html#entry_path) (roughly, a file-system-like way of arranging payloads hierarchically within a subspace) of type [`Path`],
/// - a [timestamp](https://willowprotocol.org/specs/data-model/index.html#entry_timestamp) (newer Entries can overwrite certain older Entries) of type [`Timestamp`],
/// - a [payload_length](https://willowprotocol.org/specs/data-model/index.html#entry_payload_length) (the length of the payload string), and
/// - a [payload_digest](https://willowprotocol.org/specs/data-model/index.html#entry_payload_digest) (a secure hash of the payload string being inserted into Willow) of type [`PayloadDigest`].
///
/// To access these six fields, use the methods of the [`Entrylike`] trait (which [`Entry`] implements). The [`EntrylikeExt`] trait provides additional helper methods, for example, methods to check which Entries can delete which other Entries.
///
/// To create Entries, use the [`Entry::builder`] or [`Entry::prefilled_builder`] functions.
///
/// # Example
///
/// ```
/// use willow25::prelude::*;
///
/// let entry = Entry::builder()
///     .namespace_id([0; 32].into())
///     .subspace_id([1; 32].into())
///     .path(path!("/vacation/plan"))
///     .timestamp(12345)
///     .payload_digest([77; 32].into())
///     .payload_length(17)
///     .build();
///
/// assert_eq!(*entry.subspace_id(), [1; 32].into());
///
/// let newer = Entry::prefilled_builder(&entry).timestamp(99999).build();
/// assert!(newer.prunes(&entry));
/// ```
///
/// [Spec definition](https://willowprotocol.org/specs/data-model/index.html#Entry).
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Hash, bon::Builder)]
#[cfg_attr(feature = "dev", derive(Arbitrary))]
#[builder(state_mod(vis = "pub"), on(_, overwritable))]
pub struct Entry {
    pub(crate) namespace_id: NamespaceId,
    pub(crate) subspace_id: SubspaceId,
    pub(crate) path: Path,
    #[builder(into)]
    pub(crate) timestamp: Timestamp,
    pub(crate) payload_length: u64,
    pub(crate) payload_digest: PayloadDigest,
}

#[doc(hidden)]
pub type BuilderComplete = entry_builder::SetPayloadLength<
    entry_builder::SetPayloadDigest<
        entry_builder::SetTimestamp<
            entry_builder::SetPath<entry_builder::SetSubspaceId<entry_builder::SetNamespaceId>>,
        >,
    >,
>;

impl Entry {
    // /// Creates a builder for [`Entry`].
    // ///
    // /// # Examples
    // ///
    // /// ```compile_fail
    // /// use willow25::prelude::*;
    // ///
    // /// // Supplying incomplete data errors.
    // /// Entry::builder()
    // ///     .path(path!(""))
    // ///     .namespace_id([0; 32].into())
    // ///     .subspace_id([1; 32].into())
    // ///     .payload_digest([77; 32].into())
    // ///     // fails to compile because timestamp and payload_length are missing!
    // ///     .build();
    // /// ```
    // ///
    // /// ```
    // /// # use willow25::prelude::*;
    // /// // Supplying all necessary data yields an entry.
    // /// let entry = Entry::builder()
    // ///     .namespace_id([0; 32].into())
    // ///     .subspace_id([1; 32].into())
    // ///     .path(path!(""))
    // ///     .timestamp(12345)
    // ///     .payload_digest([77; 32].into())
    // ///     .payload_length(17)
    // ///     .build();
    // ///
    // /// assert_eq!(*entry.subspace_id(), [1; 32].into());
    // /// ```
    // pub fn builder() -> EntryBuilder {
    //     wdm::Entry::builder().into()
    // }

    /// Creates a builder which is prefilled with the data from some other entry.
    ///
    /// Use this function to create modified copies of entries.
    ///
    /// # Examples
    ///
    /// ```
    /// use willow25::prelude::*;
    ///
    /// // Supplying all necessary data yields an entry.
    /// let first_entry = Entry::builder()
    ///     .namespace_id([0; 32].into())
    ///     .subspace_id([1; 32].into())
    ///     .path(path!(""))
    ///     .timestamp(12345)
    ///     .payload_digest([77; 32].into())
    ///     .payload_length(17)
    ///     .build();
    ///
    /// assert_eq!(*first_entry.payload_digest(), [77; 32].into());
    ///
    /// let second_entry = Entry::prefilled_builder(&first_entry)
    ///     .timestamp(67890)
    ///     .payload_digest([78; 32].into())
    ///     .payload_length(4)
    ///     .build();
    ///
    /// assert_eq!(*second_entry.payload_digest(), [78; 32].into());
    /// ```
    pub fn prefilled_builder<E>(source: &E) -> EntryBuilder<BuilderComplete>
    where
        E: Entrylike + ?Sized,
    {
        Self::builder()
            .namespace_id(source.namespace_id().clone())
            .subspace_id(source.subspace_id().clone())
            .path(source.path().clone())
            .timestamp(source.timestamp())
            .payload_digest(source.payload_digest().clone())
            .payload_length(source.payload_length())
    }

    /// Creates an [`Entry`] with [equal data](EntrylikeExt::entry_eq) to that of the given [`Entrylike`].
    ///
    /// ```
    /// # #[cfg(feature = "dev")] {
    /// use willow25::prelude::*;
    /// use willow25::defaults::default_entry;
    ///
    /// let entry1 = default_entry();
    ///
    /// let entry2 = Entry::from_entrylike(&entry1);
    /// assert_eq!(entry1, entry2);
    /// # }
    /// ```
    pub fn from_entrylike<E>(entrylike_to_clone: &E) -> Self
    where
        E: Entrylike + ?Sized,
    {
        Self::prefilled_builder(entrylike_to_clone).build()
    }

    /// Turns `self` into an [`AuthorisedEntry`] by creating an authorisation token for it.
    ///
    /// ```
    /// use rand::rngs::OsRng;
    /// use willow25::prelude::*;
    /// use willow25::authorisation::PossiblyAuthorisedEntry;
    ///
    /// # #[cfg(feature = "dev")] {
    /// let mut csprng = OsRng;
    /// let (subspace_id, secret) = randomly_generate_subspace(&mut csprng);
    /// let namespace_id = NamespaceId::from_bytes(&[17; 32]);
    ///
    /// let entry = Entry::builder()
    ///     .namespace_id(namespace_id.clone())
    ///     .subspace_id(subspace_id.clone())
    ///     .path(path!("/ideas"))
    ///     .timestamp(12345)
    ///     .payload(b"chocolate with mustard")
    ///     .build();
    ///
    /// let mut cap = WriteCapability::new_communal(
    ///     namespace_id.clone(),
    ///     subspace_id.clone(),
    /// );
    ///
    /// let authed = entry.into_authorised_entry(&cap, &secret);
    /// assert!(authed.is_ok());
    /// # }
    /// ```
    pub fn into_authorised_entry(
        self,
        write_capability: &WriteCapability,
        secret: &SubspaceSecret,
    ) -> Result<AuthorisedEntry, DoesNotAuthorise> {
        let authorisation_token =
            AuthorisationToken::new_for_entry(&self, write_capability, secret)?;

        Ok(PossiblyAuthorisedEntry {
                entry: self,
                authorisation_token,
            }
            .into_authorised_entry().expect("`AuthorisationToken::new_for_entry` must produce an authorisation token that authorises the entry"))
    }
}

impl Keylike for Entry {
    fn subspace_id(&self) -> &SubspaceId {
        &self.subspace_id
    }

    fn path(&self) -> &Path {
        &self.path
    }
}

impl Coordinatelike for Entry {
    fn timestamp(&self) -> Timestamp {
        self.timestamp
    }
}

impl Namespaced for Entry {
    fn namespace_id(&self) -> &NamespaceId {
        &self.namespace_id
    }
}

impl Entrylike for Entry {
    fn payload_length(&self) -> u64 {
        self.payload_length
    }

    fn payload_digest(&self) -> &PayloadDigest {
        &self.payload_digest
    }
}

/// Implements [encode_entry](https://willowprotocol.org/specs/encodings/index.html#encode_entry).
impl Encodable for Entry {
    async fn encode<C>(&self, consumer: &mut C) -> Result<(), C::Error>
    where
        C: BulkConsumer<Item = u8> + ?Sized,
    {
        self.encode_entry(consumer).await
    }
}

/// Implements [encode_entry](https://willowprotocol.org/specs/encodings/index.html#encode_entry).
impl EncodableKnownLength for Entry {
    fn len_of_encoding(&self) -> usize {
        self.length_of_entry_encoding()
    }
}

/// Implements [EncodeEntry](https://willowprotocol.org/specs/encodings/index.html#EncodeEntry).
impl Decodable for Entry {
    type ErrorReason = Blame;

    async fn decode<P>(
        producer: &mut P,
    ) -> Result<Self, DecodeError<P::Final, P::Error, Self::ErrorReason>>
    where
        P: BulkProducer<Item = u8> + ?Sized,
        Self: Sized,
    {
        Ok(Self {
            namespace_id: producer
                .produce_decoded_canonic()
                .await
                .map_err(|err| err.map_other(Into::into))?,
            subspace_id: producer
                .produce_decoded_canonic()
                .await
                .map_err(|err| err.map_other(Into::into))?,
            path: producer.produce_decoded().await?,
            timestamp: cu64_decode_standalone(producer)
                .await
                .map_err(|err| err.map_other(|_| unreachable!()))?
                .into(),
            payload_length: cu64_decode_standalone(producer)
                .await
                .map_err(|err| err.map_other(|_| unreachable!()))?,
            payload_digest: producer
                .produce_decoded_canonic()
                .await
                .map_err(|err| err.map_other(Into::into))?,
        })
    }
}

/// Implements [encode_entry](https://willowprotocol.org/specs/encodings/index.html#encode_entry).
impl DecodableCanonic for Entry {
    type ErrorCanonic = Blame;

    async fn decode_canonic<P>(
        producer: &mut P,
    ) -> Result<Self, DecodeError<P::Final, P::Error, Self::ErrorCanonic>>
    where
        P: BulkProducer<Item = u8> + ?Sized,
        Self: Sized,
    {
        Ok(Self {
            namespace_id: producer
                .produce_decoded_canonic()
                .await
                .map_err(|err| err.map_other(Into::into))?,
            subspace_id: producer
                .produce_decoded_canonic()
                .await
                .map_err(|err| err.map_other(Into::into))?,
            path: producer.produce_decoded_canonic().await?,
            timestamp: cu64_decode_canonic_standalone(producer)
                .await
                .map_err(|err| err.map_other(|_| unreachable!()))?
                .into(),
            payload_length: cu64_decode_canonic_standalone(producer)
                .await
                .map_err(|err| err.map_other(|_| unreachable!()))?,
            payload_digest: producer
                .produce_decoded_canonic()
                .await
                .map_err(|err| err.map_other(Into::into))?,
        })
    }
}

impl<State: entry_builder::State> EntryBuilder<State> {
    /// Sets the [timestamp](https://willowprotocol.org/specs/data-model/index.html#entry_timestamp) of the entry being built to the current time.
    ///
    /// ```
    /// use willow25::prelude::*;
    ///
    /// let entry = Entry::builder()
    ///     .now().unwrap()
    ///     .namespace_id([0; 32].into())
    ///     .subspace_id([1; 32].into())
    ///     .path(path!("/vacation/plan"))
    ///     .payload_digest([77; 32].into())
    ///     .payload_length(17)
    ///     .build();
    ///
    /// assert!(entry.timestamp() > 814673376414009.into());
    /// // 814673376414009 is the timestamp for 26.10.2025 afternoon-ish in Berlin.
    /// ```
    #[cfg(feature = "std")]
    pub fn now(self) -> Result<EntryBuilder<entry_builder::SetTimestamp<State>>, HifitimeError> {
        Timestamp::now().map(|ts| self.timestamp(ts))
    }

    /// Sets the [payload_length](https://willowprotocol.org/specs/data-model/index.html#entry_payload_length) and [payload_digest](https://willowprotocol.org/specs/data-model/index.html#entry_payload_digest) of the entry being built to those of the given [Payload](https://willowprotocol.org/specs/data-model/index.html#Payload).
    ///
    /// ```
    /// use willow25::prelude::*;
    ///
    /// let entry = Entry::builder()
    ///     .namespace_id([0; 32].into())
    ///     .subspace_id([1; 32].into())
    ///     .path(path!("/vacation/plan"))
    ///     .timestamp(12345)
    ///     .payload(b"See all the sights!")
    ///     .build();
    ///
    /// assert_eq!(*entry.payload_digest(), [
    ///     91, 29, 243, 211, 140, 181, 127, 138,
    ///     116, 79, 56, 47, 85, 50, 157, 82,
    ///     55, 192, 253, 122, 72, 250, 70, 43,
    ///     56, 116, 99, 53, 188, 85, 83, 234,
    /// ].into());
    /// assert_eq!(entry.payload_length(), 19);
    /// ```
    pub fn payload<Payload>(
        self,
        payload: Payload,
    ) -> EntryBuilder<entry_builder::SetPayloadLength<entry_builder::SetPayloadDigest<State>>>
    where
        Payload: AsRef<[u8]>,
    {
        let mut hasher = William3Hasher::default();
        hasher.write(payload.as_ref());

        let digest = hasher.finish().into();
        // realistically this shouldn't panic; a payload should never be longer than `u64::MAX` bytes
        let length = u64::try_from(payload.as_ref().len()).expect("payload too long");

        self.payload_digest(digest).payload_length(length)

        // bab_rs::William3Digest
    }

    /// Sets the [payload_length](https://willowprotocol.org/specs/data-model/index.html#entry_payload_length) and [payload_digest](https://willowprotocol.org/specs/data-model/index.html#entry_payload_digest) of the entry being built to those of the payload given by the producer.
    ///
    /// ```
    /// use willow25::prelude::*;
    /// use ufotofu::producer::clone_from_slice;
    ///
    /// # pollster::block_on(async {
    /// let mut producer = clone_from_slice(b"See all the sights!");
    ///
    /// let entry = Entry::builder()
    ///     .namespace_id([0; 32].into())
    ///     .subspace_id([1; 32].into())
    ///     .path(path!("/vacation/plan"))
    ///     .timestamp(12345)
    ///     .payload_async(&mut producer).await.unwrap()
    ///     .build();
    ///
    /// assert_eq!(*entry.payload_digest(), [
    ///     91, 29, 243, 211, 140, 181, 127, 138,
    ///     116, 79, 56, 47, 85, 50, 157, 82,
    ///     55, 192, 253, 122, 72, 250, 70, 43,
    ///     56, 116, 99, 53, 188, 85, 83, 234,
    /// ].into());
    /// assert_eq!(entry.payload_length(), 19);
    /// # })
    /// ```
    pub async fn payload_async<P>(
        self,
        payload_producer: &mut P,
    ) -> Result<
        EntryBuilder<entry_builder::SetPayloadLength<entry_builder::SetPayloadDigest<State>>>,
        P::Error,
    >
    where
        P: BulkProducer<Item = u8, Final = ()>,
    {
        let mut hasher = William3Hasher::default();
        let mut payload_len = 0;
        loop {
            match payload_producer
                .expose_items_sync(|partial_payload| {
                    hasher.write(partial_payload);
                    payload_len += partial_payload.len();
                    (partial_payload.len(), ())
                })
                .await?
            {
                Either::Left(_) => {}
                Either::Right(_) => {
                    let payload_digest = hasher.finish().into();
                    // realistically this shouldn't panic; a payload should never be longer than `u64::MAX` bytes
                    let payload_length = u64::try_from(payload_len).expect("payload too long");
                    return Ok(self
                        .payload_digest(payload_digest)
                        .payload_length(payload_length));
                }
            }
        }
    }

    /// Sets the [namespace_id](https://willowprotocol.org/specs/data-model/index.html#entry_namespace_id) of the entry being built to the [default_namespace_id](https://willowprotocol.org/specs/willow25/index.html#willow25_default_namespace_id).
    pub fn default_namespace_id(self) -> EntryBuilder<entry_builder::SetNamespaceId<State>> {
        self.namespace_id(crate::defaults::default_namespace_id())
    }

    /// Sets the [subspace_id](https://willowprotocol.org/specs/data-model/index.html#entry_subspace_id) of the entry being built to the [default_subspace_id](https://willowprotocol.org/specs/willow25/index.html#willow25_default_subspace_id).
    pub fn default_subspace_id(self) -> EntryBuilder<entry_builder::SetSubspaceId<State>> {
        self.subspace_id(crate::defaults::default_subspace_id())
    }

    /// Sets the [payload_digest](https://willowprotocol.org/specs/data-model/index.html#entry_payload_digest) and [payload_length](https://willowprotocol.org/specs/data-model/index.html#entry_payload_length) of the entry being built to the [default_payload_digest](https://willowprotocol.org/specs/confidential-sync/index.html#sync_default_payload_digest).
    pub fn default_payload(
        self,
    ) -> EntryBuilder<entry_builder::SetPayloadLength<entry_builder::SetPayloadDigest<State>>> {
        self.payload_digest(crate::defaults::default_payload_digest())
            .payload_length(crate::defaults::DEFAULT_PAYLOAD_LENGTH)
    }
}