//! Link specifier objects

//!

//! (These are in a separate crate, since they get used both by

//! directory code and protocol code.)

use std::net::{IpAddr, SocketAddr};

use tor_bytes::{Error, Readable, Reader, Result, Writeable, Writer};

use tor_llcrypto::pk::ed25519;

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

/// A piece of information about a relay and how to connect to it.

#[non_exhaustive]

pub enum LinkSpec {

    /// The TCP address of an OR Port for a relay

    OrPort(IpAddr, u16),

    /// The RSA identity fingerprint of the relay

    RsaId(RsaIdentity),

    /// The Ed25519 identity of the relay

    Ed25519Id(ed25519::Ed25519Identity),

    /// A link specifier that we didn't recognize

    Unrecognized(u8, Vec<u8>),

}

/// Indicates an IPv4 ORPORT link specifier.

const LSTYPE_ORPORT_V4: u8 = 0;

/// Indicates an IPv6 ORPORT link specifier.

const LSTYPE_ORPORT_V6: u8 = 1;

/// Indicates an RSA ID fingerprint link specifier

const LSTYPE_RSAID: u8 = 2;

/// Indicates an Ed25519 link specifier

const LSTYPE_ED25519ID: u8 = 3;

impl Readable for LinkSpec {

        /// Return the expected length of the link specifier whose type is tp.

            }

            LSTYPE_ORPORT_V4 => {

            }

            LSTYPE_ORPORT_V6 => {

            }

        })

}

impl Writeable for LinkSpec {

        use LinkSpec::*;

            }

        }

}

impl From<&SocketAddr> for LinkSpec {

}

impl From<SocketAddr> for LinkSpec {

}

impl From<RsaIdentity> for LinkSpec {

}

impl From<ed25519::Ed25519Identity> for LinkSpec {

}

impl From<ed25519::PublicKey> for LinkSpec {

}

impl LinkSpec {

    /// Helper: return the position in the list of identifiers

    /// in which a given linkspec should occur.

    fn sort_pos(&self) -> u8 {

        use LinkSpec::*;

        }

    /// Sort a slice of LinkSpec based on the order in which they should

    /// appear in an EXTEND cell.

}

#[cfg(test)]

mod test {

    #![allow(clippy::unwrap_used)]

    use super::*;

    use hex_literal::hex;

    use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

    use tor_bytes::{Reader, Writer};

    #[test]

    fn test_parse_enc() {

        fn t(b: &[u8], val: &LinkSpec) {

            let mut r = Reader::from_slice(b);

            let got: LinkSpec = r.extract().unwrap();

            assert_eq!(r.remaining(), 0);

            assert_eq!(&got, val);

            let mut v = Vec::new();

            v.write(val);

            assert_eq!(&v[..], b);

        }

        t(

            &hex!("00 06 01020304 0050"),

            &LinkSpec::OrPort(IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4)), 80),

        );

        t(

            &hex!("01 12 0001 0002 0003 0004 0005 0006 0007 0008 01bb"),

            &LinkSpec::OrPort(IpAddr::V6(Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 8)), 443),

        );

        t(

            &[

                2, 20, 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33, 33, 33, 33, 33,

                33, 33, 33, 33,

            ],

            &LinkSpec::RsaId(RsaIdentity::from_bytes(b"hello world!!!!!!!!!").unwrap()),

        );

        let key = ed25519::PublicKey::from_bytes(&hex!(

            "B440EEDB32D5C89EF21D6B16BE85A658774CE5992355737411678EE1041BDFBA"

        ))

        .unwrap()

        .into();

        t(

            &hex!("03 20 B440EEDB32D5C89EF21D6B16BE85A658774CE5992355737411678EE1041BDFBA"),

            &LinkSpec::Ed25519Id(key),

        );

        t(

            &[77, 7, 115, 116, 114, 97, 110, 103, 101],

            &LinkSpec::Unrecognized(77, (&b"strange"[..]).into()),

        );

    }

    #[test]

    fn test_parse_bad() {

        use tor_bytes::Error;

        fn t(b: &[u8]) -> Error {

            let mut r = Reader::from_slice(b);

            let got: Result<LinkSpec> = r.extract();

            got.err().unwrap()

        }

        assert!(matches!(t(&hex!("00 03")), Error::BadMessage(_)));

        assert!(matches!(t(&hex!("00 06 01020304")), Error::Truncated));

        assert!(matches!(t(&hex!("99 07 010203")), Error::Truncated));

    }

}