//! Types to describe information about other downloaded directory

//! documents, without necessarily having the full document.

//!

//! These types are all local within tor-dirmgr.  They're used so that

//! the storage code doesn't need to know about all of the parsed

//! types from tor-netdoc.

use digest::Digest;

use tor_llcrypto as ll;

use tor_netdoc::doc::{

    authcert::{AuthCert, AuthCertKeyIds},

    netstatus::{Lifetime, MdConsensus, UnvalidatedMdConsensus},

};

use std::time::SystemTime;

/// Information about a consensus that we have in storage.

///

/// This information is ordinarily derived from the consensus, but doesn't

/// have to be.

#[derive(Debug, Clone)]

pub(crate) struct ConsensusMeta {

    /// The time over which the consensus is valid.

    lifetime: Lifetime,

    /// A sha3-256 digest of the signed portion of the consensus: used for

    /// fetching diffs.

    sha3_256_of_signed: [u8; 32],

    /// A sha3-256 digest of the entirety of the consensus: used for

    /// naming the file.

    sha3_256_of_whole: [u8; 32],

}

impl ConsensusMeta {

    /// Create a new ConsensusMeta

    /// Derive a new ConsensusMeta from an UnvalidatedMdConsensus and the

    /// text of its signed portion.

    /// Derive a new ConsensusMeta from a MdConsensus and the text of its

    /// signed portion.

    #[allow(unused)]

    /// Return the lifetime of this ConsensusMeta

    /// Return the sha3-256 of the signed portion of this consensus.

    /// Return the sha3-256 of the entirety of this consensus.

}

/// Compute the sha3-256 digests of signed_part on its own, and of

/// signed_part concatenated with remainder.

/// Information about an authority certificate that we have in storage.

///

/// This information is ordinarily derived from the authority cert, but it

/// doesn't have to be.

#[derive(Clone, Debug)]

pub(crate) struct AuthCertMeta {

    /// Key IDs (identity and signing) for the certificate.

    ids: AuthCertKeyIds,

    /// Time of publication.

    published: SystemTime,

    /// Expiration time.

    expires: SystemTime,

}

impl AuthCertMeta {

    /// Construct a new AuthCertMeta from its components

    /// Construct a new AuthCertMeta from a certificate.

    /// Return the key IDs for this certificate

    /// Return the published time for this certificate

    /// Return the expiration time for this certificate

}

#[cfg(test)]

mod test {

    // @@ begin test lint list maintained by maint/add_warning @@

    #![allow(clippy::bool_assert_comparison)]

    #![allow(clippy::clone_on_copy)]

    #![allow(clippy::dbg_macro)]

    #![allow(clippy::mixed_attributes_style)]

    #![allow(clippy::print_stderr)]

    #![allow(clippy::print_stdout)]

    #![allow(clippy::single_char_pattern)]

    #![allow(clippy::unwrap_used)]

    #![allow(clippy::unchecked_duration_subtraction)]

    #![allow(clippy::useless_vec)]

    #![allow(clippy::needless_pass_by_value)]

    //! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

    use super::*;

    #[test]

    fn t_sha3_dual() {

        let s = b"Loarax ipsum gruvvulus thneed amet, snergelly once-ler lerkim, sed do barbaloot tempor gluppitus ut labore et truffula magna aliqua. Ut enim ad grickle-grass veniam, quis miff-muffered ga-zumpco laboris nisi ut cruffulus ex ea schloppity consequat. Duis aute snarggle in swomeeswans in voluptate axe-hacker esse rippulus crummii eu moof nulla snuvv.";

        let sha3_of_whole: [u8; 32] = ll::d::Sha3_256::digest(s).into();

        for idx in 0..s.len() {

            let sha3_of_part: [u8; 32] = ll::d::Sha3_256::digest(&s[..idx]).into();

            let (a, b) = sha3_dual(&s[..idx], &s[idx..]);

            assert_eq!(a, sha3_of_part);

            assert_eq!(b, sha3_of_whole);

        }

    }

}