//! Implements the relay 'family' type.

//!

//! Families are opt-in lists of relays with the same operators,

//! used to avoid building insecure circuits.

use std::sync::Arc;

use crate::types::misc::LongIdent;

use crate::{Error, NetdocErrorKind, NormalItemArgument, Pos, Result};

use base64ct::Encoding;

use derive_deftly::Deftly;

use tor_basic_utils::intern::InternCache;

use tor_llcrypto::pk::ed25519::{ED25519_ID_LEN, Ed25519Identity};

use tor_llcrypto::pk::rsa::RsaIdentity;

/// Information about a relay family.

///

/// Tor relays may declare that they belong to the same family, to

/// indicate that they are controlled by the same party or parties,

/// and as such should not be used in the same circuit. Two relays

/// belong to the same family if and only if each one lists the other

/// as belonging to its family.

///

/// NOTE: when parsing, this type always discards incorrectly-formatted

/// entries, including entries that are only nicknames.

///

/// TODO: This type probably belongs in a different crate.

#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deftly)]

#[cfg_attr(feature = "parse2", derive_deftly(ItemValueParseable))]

pub struct RelayFamily(Vec<LongIdent>);

/// Cache of RelayFamily objects, for saving memory.

//

/// This only holds weak references to the policy objects, so we don't

/// need to worry about running out of space because of stale entries.

static FAMILY_CACHE: InternCache<RelayFamily> = InternCache::new();

impl RelayFamily {

    /// Return a new empty RelayFamily.

    /// Add `rsa_id` to this family.

    /// Convert this family to a standard format (with all IDs sorted and de-duplicated).

    /// Consume this family, and return a new canonical interned representation

    /// of the family.

    /// Does this family include the given relay?

    /// Return an iterator over the RSA identity keys listed in this

    /// family.

    /// Return true if this family has no members.

}

impl std::str::FromStr for RelayFamily {

    type Err = Error;

}

/// An identifier representing a relay family.

///

/// In the ["happy families"](https://spec.torproject.org/proposals/321) scheme,

/// microdescriptors will no longer have to contain a list of relay members,

/// but will instead contain these identifiers.

///

/// If two relays have a `RelayFamilyId` in common, they belong to the same family.

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

#[non_exhaustive]

pub enum RelayFamilyId {

    /// An identifier derived from an Ed25519 relay family key. (`KP_familyid_ed`)

    Ed25519(Ed25519Identity),

    /// An unrecognized string.

    Unrecognized(String),

}

/// Prefix for a RelayFamilyId derived from an ed25519 `KP_familyid_ed`.

const ED25519_ID_PREFIX: &str = "ed25519:";

impl std::str::FromStr for RelayFamilyId {

    type Err = Error;

}

impl std::fmt::Display for RelayFamilyId {

        }

}

impl PartialOrd for RelayFamilyId {

}

impl Ord for RelayFamilyId {

        // We sort RelayFamilyId values by string representation.

        // This is not super-efficient, but we don't need to do it very often.

}

impl NormalItemArgument for RelayFamilyId {}

/// A list of multiple [`RelayFamilyId`] entries as found in microdescs.

#[derive(Clone, Debug, Default, Eq, PartialEq, Deftly, derive_more::AsRef)]

#[cfg_attr(feature = "parse2", derive_deftly(ItemValueParseable))]

pub struct RelayFamilyIds(Vec<RelayFamilyId>);

impl RelayFamilyIds {

    /// Return a new empty [`RelayFamilyIds`].

    /// Push `family_id` onto this instance.

}

impl FromIterator<RelayFamilyId> for RelayFamilyIds {

}

#[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_time_subtraction)]

    #![allow(clippy::useless_vec)]

    #![allow(clippy::needless_pass_by_value)]

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

    use std::str::FromStr;

    use super::*;

    use crate::Result;

    #[test]

    fn family() -> Result<()> {

        let f = "nickname1 nickname2 $ffffffffffffffffffffffffffffffffffffffff=foo eeeeeeeeeeeeeeeeeeeEEEeeeeeeeeeeeeeeeeee ddddddddddddddddddddddddddddddddd  $cccccccccccccccccccccccccccccccccccccccc~blarg ".parse::<RelayFamily>()?;

        let v = vec![

            RsaIdentity::from_bytes(

                &hex::decode("ffffffffffffffffffffffffffffffffffffffff").unwrap()[..],

            )

            .unwrap(),

            RsaIdentity::from_bytes(

                &hex::decode("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee").unwrap()[..],

            )

            .unwrap(),

            RsaIdentity::from_bytes(

                &hex::decode("cccccccccccccccccccccccccccccccccccccccc").unwrap()[..],

            )

            .unwrap(),

        ];

        assert_eq!(f.members().cloned().collect::<Vec<_>>(), v);

        Ok(())

    }

    #[test]

    fn test_contains() -> Result<()> {

        let family =

            "ffffffffffffffffffffffffffffffffffffffff eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"

                .parse::<RelayFamily>()?;

        let in_family = RsaIdentity::from_bytes(

            &hex::decode("ffffffffffffffffffffffffffffffffffffffff").unwrap()[..],

        )

        .unwrap();

        let not_in_family = RsaIdentity::from_bytes(

            &hex::decode("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").unwrap()[..],

        )

        .unwrap();

        assert!(family.contains(&in_family), "Relay not found in family");

        assert!(

            !family.contains(&not_in_family),

            "Extra relay found in family"

        );

        Ok(())

    }

    #[test]

    fn mutable() {

        let mut family = RelayFamily::default();

        let key = RsaIdentity::from_hex("ffffffffffffffffffffffffffffffffffffffff").unwrap();

        assert!(!family.contains(&key));

        family.push(key);

        assert!(family.contains(&key));

    }

    #[test]

    fn family_ids() {

        let ed_str_rep = "ed25519:7sToQRuge1bU2hS0CG0ViMndc4m82JhO4B4kdrQey80";

        let ed_id = RelayFamilyId::from_str(ed_str_rep).unwrap();

        assert!(matches!(ed_id, RelayFamilyId::Ed25519(_)));

        assert_eq!(ed_id.to_string().as_str(), ed_str_rep);

        let other_str_rep = "hello-world";

        let other_id = RelayFamilyId::from_str(other_str_rep).unwrap();

        assert!(matches!(other_id, RelayFamilyId::Unrecognized(_)));

        assert_eq!(other_id.to_string().as_str(), other_str_rep);

        assert_eq!(ed_id, ed_id);

        assert_ne!(ed_id, other_id);

    }

    #[test]

    #[cfg(feature = "parse2")]

    fn parse2() {

        #[derive(Debug, PartialEq, Eq, derive_deftly::Deftly)]

        #[cfg_attr(feature = "parse2", derive_deftly(NetdocParseable))]

        struct Wrapper {

            family: RelayFamily,

        }

        const LINE: &str = "family $0000000000000000000000000000000000000000 $FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";

        let parsed =

            crate::parse2::parse_netdoc::<Wrapper>(&crate::parse2::ParseInput::new(LINE, ""))

                .unwrap();

        assert_eq!(

            parsed,

            Wrapper {

                family: RelayFamily(vec![

                    RsaIdentity::from_hex("0000000000000000000000000000000000000000")

                        .unwrap()

                        .into(),

                    RsaIdentity::from_hex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")

                        .unwrap()

                        .into()

                ])

            }

        );

    }

}